Buscar..
tipo de
typeof es la función 'oficial' que se usa para obtener el type en javascript, sin embargo, en ciertos casos puede dar resultados inesperados ...
1. cuerdas
typeof "String" o
typeof Date(2011,01,01)
"cuerda"
2. Números
typeof 42
"número"
3. Bool
typeof true (valores válidos true y false )
booleano
4. Objeto
typeof {} o
typeof [] o
typeof null o
typeof /aaa/ or
typeof Error()
"objeto"
5. Función
typeof function(){}
"función"
6. indefinido
var var1; typeof var1
"indefinido"
Obtención del tipo de objeto por nombre de constructor
Cuando uno con el operador typeof uno obtiene un object tipo, cae en una categoría un poco perdida ...
En la práctica, es posible que deba limitarlo a qué tipo de 'objeto' es realmente y una forma de hacerlo es usar el nombre del constructor de objetos para obtener el sabor del objeto que realmente es: Object.prototype.toString.call(yourObject)
1. cuerda
Object.prototype.toString.call("String")
"[cadena de objeto]"
2. Número
Object.prototype.toString.call(42)
"[Número de objeto]"
3. Bool
Object.prototype.toString.call(true)
"[objeto booleano]"
4. Objeto
Object.prototype.toString.call(Object()) o
Object.prototype.toString.call({})
"[objeto Objeto]"
5. Función
Object.prototype.toString.call(function(){})
"[Función objeto]"
6. fecha
Object.prototype.toString.call(new Date(2015,10,21))
"[fecha del objeto]"
7. Regex
Object.prototype.toString.call(new RegExp()) o
Object.prototype.toString.call(/foo/);
"[objeto RegExp]"
8. Array
Object.prototype.toString.call([]);
"[Object Array]"
9. Nulo
Object.prototype.toString.call(null);
"[objeto nulo]"
10. indefinido
Object.prototype.toString.call(undefined);
"[objeto no definido]"
11. error
Object.prototype.toString.call(Error());
"[error de objeto]"
Encontrar la clase de un objeto
Para encontrar si un objeto fue construido por un determinado constructor o uno heredado de él, puede usar el comando instanceof :
//We want this function to take the sum of the numbers passed to it
//It can be called as sum(1, 2, 3) or sum([1, 2, 3]) and should give 6
function sum(...arguments) {
if (arguments.length === 1) {
const [firstArg] = arguments
if (firstArg instanceof Array) { //firstArg is something like [1, 2, 3]
return sum(...firstArg) //calls sum(1, 2, 3)
}
}
return arguments.reduce((a, b) => a + b)
}
console.log(sum(1, 2, 3)) //6
console.log(sum([1, 2, 3])) //6
console.log(sum(4)) //4
Tenga en cuenta que los valores primitivos no se consideran instancias de ninguna clase:
console.log(2 instanceof Number) //false
console.log('abc' instanceof String) //false
console.log(true instanceof Boolean) //false
console.log(Symbol() instanceof Symbol) //false
Cada valor en JavaScript, además de null e undefined también tiene una propiedad de constructor almacena la función que se utilizó para construirlo. Esto incluso funciona con primitivos.
//Whereas instanceof also catches instances of subclasses,
//using obj.constructor does not
console.log([] instanceof Object, [] instanceof Array) //true true
console.log([].constructor === Object, [].constructor === Array) //false true
function isNumber(value) {
//null.constructor and undefined.constructor throw an error when accessed
if (value === null || value === undefined) return false
return value.constructor === Number
}
console.log(isNumber(null), isNumber(undefined)) //false false
console.log(isNumber('abc'), isNumber([]), isNumber(() => 1)) //false false false
console.log(isNumber(0), isNumber(Number('10.1')), isNumber(NaN)) //true true true
