Introducción
Saber cuál es el tipo de un dato suele ser muy importante para que el código se ejecute sin problemas y sin errores.
JavaScript tiene varias formas de comprobar el tipo de un valor o 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 fuertes, 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 [motivos históricos][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 en función de si el segundo operando está incluido en la cadena de prototipos del primer operando.
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 contexto distinto, como un iframe en una página web, Array.isArray() sí lo hará.
Esto se debe a que la clase Array tiene un constructor distinto en cada contexto, y cada iframe tiene su propio contexto, lo que significa que la función de la cadena de prototipos será distinta, lo que provoca que instanceof Array falle.
Array.isArray() es capaz de ignorar esto y siempre debería usarse cuando sea posible.
También puede sobrevivir a falsos positivos en los que un objeto no es realmente 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 establecida a 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 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 está 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 ha contratado un centro de reciclaje.
Debido a la falta de espacio, todos los productos se colocan en la misma cinta transportadora, pero esto ha provocado que distintos materiales se mezclen y queden inservibles.
Para solucionarlo, se te ha encargado crear funciones que identifiquen el tipo de un producto.
1. Comprobar 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. Comprobar si un valor es un número.
Implementa la función isNumber, que comprueba si un valor es un number o un bigint finitos, es decir, que no es NaN ni Infinity.
A veces, el dispositivo lector de identificadores falla y lee un valor no numérico como NaN (no es un número) o Infinity.
Tu función también debería saber manejar esto correctamente.
isNumber(42);
// => true
isNumber('Hello, World!');
// => false
isNumber(42n);
// => true
isNumber(NaN);
// => false
3. Comprobar si un valor es un objeto
Implementa la función isObject, que debe comprobar si el valor es un objeto.
En la cinta transportadora, null no es nada y no se considera un objeto.
isObject({ greeting: 'Hello' });
// => true
isObject(25n);
// => false
4. Comprobar si un string es numérico
Implementa la función isNumericString, que debe comprobar si el valor es un string formado únicamente por dígitos, o por un signo menos seguido de dígitos que indique un número negativo.
Solo deben considerarse números enteros; los números decimales no se consideran numéricos para esta comprobación del robot de reciclaje.
isNumericString(42);
// => false
isNumericString('42');
// => true
isNumericString('Hi!');
// => false
5. Comprobar 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. Comprobar 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. Comprobar 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. Comprobar 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. Lanzar 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 debe devolver nada.
assertHasId({ id: 42, color: 'red' });
// => undefined
assertHasId({ color: 'green' });
// Error: "Object is missing the 'id' property"
10. Comprobar 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. Comprobar 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
