¿Por qué el tipo de javascript siempre devuelve "objeto"?

Question

¿Para qué se usa si siempre devuelve "objeto" como tipo?

--update

siempre por elementos o listas.

Answer 1

typeof de JS no siempre devuelve 'objeto', pero lo hace objeto de devolver lo que la gente puede no consideran que son objetos - es decir, matrices, y también, curiosamente, por los nulos.

Para las matrices esto es correcto, porque en lo que se refiere a JS, arrays son objetos; son lo mismo. Array es solo otra clase, y puedes crear instancias de objetos de tipo Array, pero todavía se tratan como objetos.

This page tiene una lista de tipos de JS, junto con la respuesta que obtendrá por cada uno de ellos de typeof. También tiene algún código JS para anular el tipo de función con uno que devuelve información más útil. Si te preocupa que no sea útil, puedes implementar algo así si lo deseas.

Answer 2

No siempre devuelve "objeto":

alert(typeof "hello"); 

Dicho esto, un truco (posiblemente) más útil para examinar objetos es utilizar Object.prototype.toString.call() y mirar el resultado:

var t = Object.prototype.toString.call(itIsAMystery); 

Eso le dará una cadena como [object Foo] con "Foo" siendo el constructor (creo) la parte interesante. Para los tipos "nativos" (como Fecha o Cadena), recuperas ese nombre de constructor.

Answer 3

Tienes que entender que el sistema de tipos en JavaScript es dinámico con algunos tipos de "primative" sobre los cuales construir. Al tratar todos los objetos complejos como el tipo "objeto", esto le permite hacer patos y llamar a métodos sin tener necesariamente que saber el tipo de objeto que se pasa, suponiendo que ese tipo tiene la llamada de función implementada. En un lenguaje de programación dinámico, todo es un "objeto".

Answer 4

En mi experiencia, el principal problema con typeof proviene de distinguir entre las matrices, los objetos y los nulos (todo el "objeto" de retorno).

Para ello, en primer lugar comprobar typeof entonces puedo comprobar el caso nulo o el constructor "del objeto", como este:

for (o in obj) { 
    if (obj.hasOwnProperty(o)) { 
     switch (typeof obj[o]) { 
      case "object": 
       if (obj[o] === null) { 
        //do somethign with null 
       } else { 
        if (obj[o].constructor.name === "Array") { 
         //do something with an Array 
        } else { 
         //do something with an Object 
        } 
       } 
       break; 
      case "function": 
       //do something with a function 
       break; 
      default: 
       //do something with strings, booleans, numbers 
       break; 
     } 
    } 
} 

Answer 5

Uno tiene que ser un poco cuidadoso con el operador typeof. Devuelve "objeto" para un nulo, "número" para NaN, "número" para Infinity, "objeto" para un "nuevo Número (1)" y "objeto" para una matriz.

Al verificar la existencia de una variable (typeof variable! == "undefined") a veces primero se debe verificar if (variable == null) porque typeof devuelve "object" para una variable asignada a null.

Esto es un poco obvio, pero también hay que tener cuidado de no invocar una función en la comprobación typeof porque el tipo de retorno de la función se informó y no "función".

Answer 6

Para agregar con los demás, typeof devuelve objetos y primitivas. Hay 5 tipos primitivos en javascript: indefinido, nulo, booleano, cadena y número. Todo lo demás es un objeto. Cuando typeof se aplica a cualquier tipo de objeto que no sea Function, simplemente devuelve "object".Cuando se aplica a una función, devuelve un objeto de función.

Así, por ejemplo:

• typeof verdadera; // devuelve el tipo primitivo "booleano"
• typeof 123; // devuelve el tipo primitivo "número"
• tipo de nulo // devuelve "objeto", lo que es un error, pero hasta ahora no hay ninguna solución en otra versión de ECMAScript, solo hable de hacerlo.
• objeto typeof // devuelve "objeto", lo cual tiene sentido

A fin de exponer más adelante la respuesta de puntiagudo, hay en cada JavaScript objeto una propiedad interna conocida como [[Clase]] en ECMAScript 5. Con el fin para mostrar el valor real del objeto, puede hacer referencia a la propiedad [[Class]] usando: Object.prototype.toString. Para evitar que algunos de los objetos incorporados especializados sobrescriban a String, utiliza el método interno de llamada que revelará el tipo de objeto real.

Así que en vez de conseguir el objeto genérico de vuelta de toString:

var dateObject = Object.prototype.toString(new Date); 
document.write(dateObject);//[object Object] 

que pueda obtener el tipo de objeto real utilizando Llamar:

var dateObject = Object.prototype.toString.call(new Date); 
document.write(dateObject);//[object Date]