Introducción
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 un objeto.
Los mecanismos de verificación de tipos de JavaScript pueden ser algo poco fiables.
Para tener mayor seguridad de tipos y tipos más sólidos, probablemente deberías 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 "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 como un boolean según si el segundo operando está incluido en la cadena de prototipos del primer operando.
Para aclararlo, instanceof devuelve 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 diferente, como un iframe en una página web, Array.isArray() sí lo hará.
Esto se debe a que la clase Array tiene un constructor diferente en cada realm, y cada iframe tiene su propio realm, lo que significa que la función en la cadena de prototipos será diferente, y eso hace que instanceof Array falle.
Array.isArray() es capaz de ignorar esto y debería usarse siempre que sea posible.
También resiste los falsos positivos en los que un objeto no es en realidad un Array y solo 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.
in igualmente detecta una propiedad cuyo valor sea undefined.
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 devuelve true para las propiedades y los métodos heredados.
"coolDown" in espresso
// => true
"constructor" in espresso
// => true
Para evitar esto, 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
Instrucciones
Instrucciones
Te contrataron en un centro de reciclaje.
Por falta de espacio, todos los productos se colocan en la misma banda transportadora, pero esto ha provocado que distintos materiales se mezclen y queden inservibles.
Para solucionarlo, te encargaron crear funciones que identifiquen el tipo de un producto.
1. Comprueba si un valor es un boolean
Implementa la función isBoolean, que comprueba si un valor es un boolean.
isBoolean(true);
// => true
isBoolean(null);
// => false
2. Comprueba si un valor es un número.
Implementa la función isNumber, que comprueba si un valor es un number o bigint finito, es decir, que no sea NaN ni Infinity.
A veces, el dispositivo que lee los ID falla y lee un valor no numérico como NaN (Not a Number, es decir, «no es un número») o Infinity.
Tu función también debería poder manejar esto correctamente.
isNumber(42);
// => true
isNumber('Hello, World!');
// => false
isNumber(42n);
// => true
isNumber(NaN);
// => false
3. Comprueba si un valor es un objeto
Implementa la función isObject, que debe comprobar si el valor es un objeto.
En la banda transportadora, null no es nada y no se considera un objeto.
isObject({ greeting: 'Hello' });
// => true
isObject(25n);
// => false
4. Comprueba si un string es numérico
Implementa la función isNumericString, que debe comprobar si el valor es un string que solo consta de dígitos, o de un signo menos seguido de dígitos que indican un número negativo.
Solo deben considerarse los enteros; para esta comprobación del robot de reciclaje, los decimales no se consideran numéricos.
isNumericString(42);
// => false
isNumericString('42');
// => true
isNumericString('Hi!');
// => false
5. Comprueba si un objeto es electrónico
Implementa la función isElectronic, que comprueba si un objeto es una instancia de la clase ElectronicDevice proporcionada o de una de sus clases hijas.
class Duck {
//...
}
class WashingMachine extends ElectronicDevice {
//...
}
isElectronic(new Duck());
// => false
isElectronic(new WashingMachine());
// => true
6. Comprueba si un valor es un array no vacío
Implementa la función isNonEmptyArray, que comprueba si un valor es un array no vacío.
isNonEmptyArray([1, 2, 3]);
// => true
isNonEmptyArray([]);
// => false
7. Comprueba si un valor es un array vacío
Implementa la función isEmptyArray, que comprueba si un valor es un array vacío.
isEmptyArray([1, 2, 3]);
// => false
isEmptyArray([]);
// => true
8. Comprueba si un objeto tiene una propiedad o un método type
Implementa la función hasType, que comprueba si un objeto tiene una propiedad o un método type.
class Keyboard(){
type(){
// ...
}
}
hasType({ type:"car", color:"red" })
// => true
hasType({ color:"green" })
// => false
hasType(new Keyboard())
// => true
9. Lanza un error si un objeto no tiene una propiedad o un método id
Implementa la función assertHasId, que lanzará un Error si a un objeto le falta la propiedad id.
Si un objeto sí tiene la propiedad id, no debería devolver nada.
assertHasId({ id: 42, color: 'red' });
// => undefined
assertHasId({ color: 'green' });
// Error: "Object is missing the 'id' property"
10. Comprueba si un objeto tiene una propiedad id
Implementa la función hasIdProperty, que comprueba si un objeto tiene una propiedad id.
class SimpleData {
constructor() {
this.number = '42';
this.id = 'BC269327FE1D9B95';
}
}
class StealingData extends SimpleData {}
class MethodData {
constructor() {
this.number = '42';
this._id = 'BC269327FE1D9B95';
}
get id() {
return this._id;
}
}
hasIdProperty(new SimpleData());
// => true
hasIdProperty(new MethodData());
// => false
hasIdProperty(new StealingData());
// => false
11. Comprueba si un objeto tiene una propiedad type definida
Implementa la función hasDefinedType, que comprueba si un objeto tiene una propiedad type que no sea undefined.
hasDefinedType({ type: undefined, color: 'red' });
// => false
hasDefinedType({ type: 'car', color: 'green' });
// => true
Ejercicio de aprendizaje
