Acerca de Comprobación de tipos
Saber cuál es el tipo de un dato suele ser muy importante para que el código funcione sin problemas y sin errores.
JavaScript tiene varias formas de comprobar el tipo de un valor o de un objeto.
Los mecanismos de comprobación de tipos de JavaScript pueden ser algo poco fiables.
Para una mayor seguridad de tipos y tipos más sólidos, probablemente te convenga usar TypeScript, un lenguaje que se basa en JavaScript, pero con la sintaxis de tipos de un lenguaje de tipado estático.
El operador typeof
El operador typeof devuelve el tipo de su operando.
La salida es un string que coincide con el nombre de uno de los tipos de datos primitivos, excepto para "null".
También puede ser "function" o "object".
typeof undefined;
// => "undefined"
typeof true;
// => "boolean"
typeof 42;
// => "number"
typeof 'Hello, World!';
// => "string"
typeof function () {
return 'Hello, World';
};
// => "function"
typeof [1, 2, 3, 4];
// => "object"
typeof { city: 'Stockholm', country: 'Sweden' };
// => "object"
Por [razones históricas][typeof null is "object"].
El operador instanceof
Para comprobar el tipo de un objeto, puedes usar el operador instanceof.
Se evalúa a un boolean según si el segundo operando está incluido en la cadena de prototipos del primero.
Para aclararlo, instanceof devolverá si el primer operando es una instancia del segundo operando o de una de sus clases hijas.
instanceof solo funciona con objetos.
class Beverage {
// ...
}
// The Coffee class is a child of the Beverage class.
class Coffee extends Beverage {
// ...
}
const java = new Coffee();
java instanceof Coffee;
// => true
java instanceof Beverage;
// => true
La clase Array tiene un método llamado Array.isArray() que comprueba si su argumento es un array.
Mientras que instanceof Array no funcionará con un array creado en un realm distinto, como un iframe de una página web, Array.isArray() sí lo hará.
Esto se debe a que la clase Array tiene un constructor distinto en cada realm, y cada iframe tiene su propio realm, lo que significa que la función de la cadena de prototipos será distinta, lo que hace que instanceof Array falle.
Array.isArray() es capaz de ignorar esto y debería usarse siempre que sea posible.
También puede sobrevivir a falsos positivos en los que un objeto no es en realidad un Array y simplemente tiene Array en su cadena de prototipos.
({ __proto__: Array.prototype }) instanceof Array
// => true
Array.isArray({ __proto__: Array.prototype })
// => false
El operador in
El operador in devuelve si el primer operando es una propiedad del segundo operando.
No comprueba que la propiedad tenga un valor definido.
Una propiedad con valor undefined seguirá siendo detectada por in.
class Coffee {
constructor() {
this.temperature = 'hot';
this.isDarkMatter = undefined;
}
coolDown() {
this.temperature = 'warm';
}
}
const espresso = new Coffee();
'temperature' in espresso;
// => true
'color' in espresso;
// => false
'isDarkMatter' in espresso;
// => true
in devolverá true para las propiedades y los métodos heredados.
"coolDown" in espresso
// => true
"constructor" in espresso
// => true
Para evitarlo, usa Object.hasOwn() en su lugar
La función Object.hasOwn()
El método Object.hasOwn() devuelve si el objeto especificado posee la propiedad indicada (no es heredada ni es un método).
class Coffee {
constructor() {
this.temperature = 'hot';
}
coolDown() {
this.temperature = 'warm';
}
}
const cappuccino = new Coffee();
Object.hasOwn(cappucino, 'temperature');
// => true
Object.hasOwn(cappucino, 'constructor');
// => false
Object.hasOwn(cappucino, 'coolDown');
// => false
1 ejercicio
Aprende Comprobación de tipos