La differenza tra assert.equal e assert.deepEqual nei test di Javascript con Mocha?

Question

Sto usando Mocha per testare un piccolo modulo nella mia applicazione Express.js. In questo modulo, una delle mie funzioni restituisce un array. Voglio verificare se l'array è corretto o meno per un dato input. Sto facendo in modo simile a questo:

suite('getWords', function(){ 
    test("getWords should return list of numbers", function() { 
     var result = ['555', '867', '5309']; 
     assert.equal(result, getWords('555-867-5309')); 
    }); 
}); 

Quando questo viene eseguito, ottengo il seguente errore di asserzione:

AssertionError: ["555","867","5309"] == ["555","867","5309"] 

Tuttavia, quando cambio la mia prova a un assert.deepEqual, il test viene superato bene. Mi chiedevo se si trattava di un caso di == vs ===, ma se entro

[1,2,3] === [1,2,3] 

nella riga di comando node.js, ho ancora ottenere falso.

Perché gli array non confrontano il modo di altri valori (ad esempio 1 == 1)? e qual è la differenza tra assert.equal e assert.deepEqual?

Answer 1

Why do arrays not compare the way other values do (e.g. 1==1)

numeri, stringhe, booleani, null, e undefined sono valori, e vengono confrontati come ci si potrebbe aspettare. 1 == 1, 'a' == 'a' e così via. La differenza tra === e == nel caso di valori è che == tenterà prima di eseguire la conversione del tipo, che è il motivo per cui '1' == 1 ma non'1' === 1.

Gli array, d'altra parte, sono oggetti. === e == in questo caso non significano che gli operandi sono semanticamente uguali, ma che essi si riferiscono allo stesso oggetto.

what is the difference between assert.equal and assert.deepEqual?

assert.equal si comporta come spiegato sopra. In realtà non funziona se gli argomenti sono !=, come si può vedere in the source. Quindi fallisce per le tue matrici di stringhe di numeri perché sebbene siano essenzialmente equivalenti, non sono lo stesso oggetto.

L'uguaglianza profonda (alias della struttura), d'altra parte, non verifica se gli operandi sono lo stesso oggetto, ma piuttosto che sono equivalenti. In un certo senso, si potrebbe dire che costringe a confrontare gli oggetti come se fossero valori.

var a = [1,2,3] 
var b = a    // As a and b both refer to the same object 
a == b     // this is true 
a === b    // and this is also true 

a = [1,2,3]   // here a and b have equivalent contents, but do not 
b = [1,2,3]   // refer to the same Array object. 
a == b     // Thus this is false. 

assert.deepEqual(a, b) // However this passes, as while a and b are not the 
         // same object, they are still arrays containing 1, 2, 3 

assert.deepEqual(1, 1) // Also passes when given equal values 

var X = function() {} 
a = new X 
b = new X 
a == b     // false, not the same object 
assert.deepEqual(a, b) // pass, both are unadorned X objects 
b.foo = 'bar' 
assert.deepEqual(a, b) // fail!