objeto - tostring javascript ejemplo

Diferencia entre Object.prototype.toString.call(arrayObj) y arrayObj.toString()

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Por qué "foo" .toString () no es lo mismo que toString.call ("foo")? 3 respuestas

He revisado algunos materiales y no he comprendido completamente el concepto cuando se trata de sintaxis, como la siguiente:

var arrObj = [1,2,3];
Object.prototype.toString.call(arrObj); //Gives "[object Array]"
arrObj.toString(); // Gives "1,2,3"

¿Cómo son las líneas 2 y 3 diferentes? Por lo que he entendido, ambos llaman al método toString con el objeto actual que se establece en ''arrObj''.

Answer 1

Dado que toString se define en Object.prototype , quienquiera que herede Object , obtendrá de manera predeterminada el método toString .

Pero, Array objetos, anula el método predeterminado toString para imprimir los elementos de la matriz como una cadena separada por comas.

Object.prototype.toString no sabe qué tipo de Objeto realmente trata. Por lo tanto, se mantiene intencionalmente genérico y siempre imprime el tipo real del Objeto. Es por eso que

console.log(Object.prototype.toString.call(arrObj));

huellas dactilares

[object Array]

que es el tipo de objeto pasado. Pero, cuando haces arrObj.toString , estás tratando de representar la matriz en su forma de Cadena, por lo que se sobrescribe toString en objetos Array para imprimir los elementos de la matriz como una cadena separada por comas.

Es por eso que ambas llamadas son diferentes.

Pero en el caso de otros objetos, toString no se anula, por lo que usarán toString de Object.prototype.toString . Por ejemplo,

var obj = {
    1: 2
};

console.log(obj.toString());
// [object Object]

Lea el ejemplo del MDN de Reemplazar el método predeterminado de toString

Answer 2

Estos métodos .call() son formas extravagantes para tratar un tipo como otro. Por ejemplo, NodeLists, como Arrays con Array.prototype.forEach . Cuando lo llamas como un Objeto lo "convertirá" en una cadena de Objeto

Array.prototype.toString.call(arrObj);

Funciona perfectamente. Object.toString() está tratando de forma extraña. Imagina al compilador haciendo algo como:

[1, 2, 3] -> { 0: 1, 1: 2, 2: 3 }

Eso devolverá [Object object] . JavaScript, a diferencia de otros idiomas, siempre encontrará una salida cuando se trata de problemas de tipo.

Si está escribiendo una función, podría hacer algo como:

function myFunction (input) {
    window[input.constructor.name].prototype.toString.call(input);
}

Answer 3

toString se reemplaza por Arrays ; y Object.prototype.toString es diferente de Array.prototype.toString .

Para obtener el mismo resultado con la call , úselo en el método "correcto":

 Array.prototype.toString.call(arrObj); // Gives "1,2,3"