web-dev-qa-db-fra.com

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

J'utilise Mocha pour tester un petit module dans mon application Express.js. Dans ce module, une de mes fonctions renvoie un tableau. Je veux tester si le tableau est correct pour une entrée donnée. Je le fais comme ça:

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

Lorsque cela fonctionne, j'obtiens l'erreur d'assertion suivante:

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

Cependant, lorsque je change mon test en un assert.deepEqual, le test réussit bien. Je me demandais s'il s'agissait d'un cas de == contre ===, mais si j'entre

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

dans la ligne de commande node.js, je reçois toujours faux.

Pourquoi les tableaux ne comparent-ils pas les autres valeurs (par exemple, 1 == 1)? et quelle est la différence entre assert.equal et assert.deepEqual?

javascriptarraystestingmocha
82
mshell_lauren

Pourquoi les tableaux ne comparent-ils pas les autres valeurs (par exemple 1 == 1)

Les nombres, les chaînes, les booléens, null et undefined sont des valeurs et sont comparés comme prévu. 1 == 1, 'a' == 'a', etc. La différence entre === et == dans le cas des valeurs est que == tentera d’abord d’effectuer la conversion de type, c’est pourquoi '1' == 1 mais pas '1' === 1.

Les tableaux, en revanche, sont des objets. === et == _ dans ce cas, ne signifie pas que les opérandes sont sémantiquement égaux, mais qu'ils se réfèrent au même objet .

quelle est la difference entre assert.equal et assert.deepEqual?

assert.equal se comporte comme expliqué ci-dessus. Il échoue si les arguments sont !=, comme vous pouvez le voir dans le source . Ainsi, vos tableaux de nombres échouent, car, s'ils sont essentiellement équivalents, ils ne sont pas le même objet.

L'égalité profonde (ou structure), en revanche, ne vérifie pas si les opérandes sont le même objet, mais plutôt qu'ils sont équivalents. En un sens, vous pourriez dire que cela oblige les objets à être comparés comme s'ils étaient des 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!
140
numbers1311407