En Javascript, ¿por qué [1, 2] == [1, 2] o ({a: 1}) == ({a: 1}) es falso?

Question

El se hace después de Firebug:

>>> [1, 2] == [1, 2] 
false 

>>> ({a : 1}) == ({a : 1}) 
false 

pensé javscript tiene una regla que dice que, si un objeto o matriz tiene las mismas referencias a los mismos elementos, entonces son iguales?

Pero incluso si digo

>>> foo = {a : 1} 
Object { a=1} 

>>> [foo] == [foo] 
false 

>>> ({a: foo}) == ({a: foo}) 
false 

¿Hay una manera de hacerlo de modo que se puede hacer la comparación del elemento y volver true?

Answer 1

{ } y [ ] son los mismos que new Object y new Array

Y new Object != new Object (ídem con Array) porque son nuevas y diferentes objetos.

Si desea saber si el contenido de dos objetos arbitrarios es la "misma" para un cierto valor de la misma a continuación, una solución rápida (pero lento) es

JSON.parse(o) === JSON.parse(o)

Una solución más elegante sería para definir una función igual (no probado)

var equal = function _equal(a, b) { 
    // if `===` or `==` pass then short-circuit 
    if (a === b || a == b) { 
    return true; 
    } 
    // get own properties and prototypes 
    var protoA = Object.getPrototypeOf(a), 
     protoB = Object.getPrototypeOf(b), 
     keysA = Object.keys(a), 
     keysB = Object.keys(b); 

    // if protos not same or number of properties not same then false 
    if (keysA.length !== keysB.length || protoA !== protoB) { 
    return false; 
    } 
    // recurse equal check on all values for properties of objects 
    return keysA.every(function (key) { 
    return _equal(a[key], b[key]); 
    }); 
}; 

equals example

Advertencia: escribiendo una función de igualdad que "funciona" en todas las entradas es difícil, algunos errores comunes son (null == undefined) === true y (NaN === NaN) === false ninguno de los cuales busqué en mi función.

Tampoco he tenido problemas con el navegador cruzado, simplemente asumí que ES5 existe.

Answer 2

Es porque los literales de objeto JavaScript no comparten los mismos punteros. En su lugar, se crea un nuevo puntero para cada uno. Consideremos el siguiente ejemplo:

>>> ({a : 1}) == ({a : 1}) 
false 

... pero ...

>>> obj = ({a : 1}); 
Object 

>>> obj == obj 
true 

obj es un puntero al objeto Litteral { a : 1 }. Esto funciona porque los punteros son los mismos cuando los compara

Answer 3

Está comparando objetos diferentes.

>>> var a = [1,2] var b = [1,2] 
>>> a == b 
false 
>>> a == a 
true 

Si desea probar la igualdad gama es posible que desee utilizar alguna biblioteca o simplemente escribir la prueba usted mismo.

Answer 4

para ver qué tipo de código es necesario para hacer la igualdad profunda que está hablando, echa un vistazo a Underscore.js's _.isEqual function o QUnit's deepEqual implementation.