In Javascript, perché [1, 2] == [1, 2] o ({a: 1}) == ({a: 1}) falso?

Question

che segue è fatto in Firebug:

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

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

ho pensato javscript ha qualche regola che dice che, se un oggetto o array ha gli stessi riferimenti agli stessi elementi, allora sono uguali?

Ma anche se io dico

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

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

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

C'è un modo per fare in modo che esso possa fare il confronto elemento e tornare true?

Answer 1

{ } e [ ] sono uguali a new Object e new Array

E new Object != new Object (idem con Array) perché sono nuovi e diversi oggetti.

Se volete sapere se il contenuto di due oggetti arbitrari è la "stessa" per un certo valore della stessa poi un rapido (ma lento) correzione è

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

Una soluzione più elegante sarebbe definire una funzione uguale (non testata)

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

Attenzione: scrivere una funzione di uguaglianza che "funziona" su tutti gli input è difficile, alcuni trucchi comuni sono (null == undefined) === true e che nessuno dei due ha previsto per la mia funzione.

Né ho mai avuto problemi con i browser, ho appena pensato che ES5 esista.

Answer 2

È perché i valori letterali oggetto javascript non condividono gli stessi puntatori. Invece viene creato un nuovo puntatore per ognuno. Si consideri il seguente esempio:

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

... ma ...

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

>>> obj == obj 
true 

obj è un puntatore all'oggetto letterale { a : 1 }. Quindi questo funziona perché i puntatori sono gli stessi quando li confronti

Answer 3

Stai comparando diversi oggetti.

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

Se si desidera verificare l'uguaglianza array che si potrebbe desiderare di utilizzare qualche libreria o semplicemente scrivere il test da soli.

Answer 4

Per vedere che tipo di codice è necessario per fare l'uguaglianza di cui parli, controlla Underscore.js's _.isEqual function o QUnit's deepEqual implementation.