JavaScript
Tipos de datos en Javascript

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