La différence entre assert.equal et assert.deepEqual dans les tests Javascript avec Mocha ?

Question

J'utilise Mocha pour tester un petit module dans mon application Express.js. Dans ce module, l'une de mes fonctions renvoie un tableau. Je veux tester si le tableau est correct ou non pour une entrée donnée. Je procède de la manière suivante :

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

Lors de l'exécution, j'obtiens l'erreur d'assertion suivante :

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

Cependant, lorsque je transforme mon test en un assert.deepEqual le test passe bien. Je me demandais si c'était un cas de == vs === mais si j'entre

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

dans la ligne de commande node.js, j'obtiens toujours false.

Pourquoi les tableaux ne sont pas comparables à d'autres valeurs (par ex. 1 == 1 ) ? et quelle est la différence entre assert.equal et assert.deepEqual ?

Answer 1

Pourquoi les tableaux ne sont pas comparables à d'autres valeurs (par exemple, 1==1) ?

Nombres, chaînes de caractères, booléens, null y undefined sont des valeurs, et sont comparées comme on peut s'y attendre. 1 == 1 , 'a' == 'a' et ainsi de suite. La différence entre === y == dans le cas des valeurs est que == tentera d'effectuer une conversion de type en premier lieu, c'est pourquoi '1' == 1 mais no '1' === 1 .

Les tableaux, en revanche, sont des objets. === y == dans ce cas, ne signifient pas que les opérandes sont sémantiquement égaux, mais qu'ils font référence au même objet .

Quelle est la différence entre assert.equal et assert.deepEqual ?

assert.equal se comporte comme expliqué ci-dessus. Il échoue en fait si les arguments sont != comme vous pouvez le voir dans la source . Il échoue donc pour vos tableaux de chaînes de chiffres car, bien qu'ils soient essentiellement équivalents, ils ne sont pas le même objet.

L'égalité profonde (ou structurelle), quant à elle, ne vérifie pas si les opérandes sont le même objet, mais plutôt s'ils sont équivalents. En un sens, on pourrait dire qu'elle force les objets à être comparés comme s'il s'agissait de valeurs.

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!