node - javascript assert library

¿La diferencia entre assert.equal y assert.deepEqual en las pruebas de Javascript con Mocha?

Question

Estoy usando Mocha para probar un pequeño módulo en mi aplicación Express.js. En este módulo, una de mis funciones devuelve una matriz. Quiero probar si la matriz es correcta para una entrada determinada. Lo estoy haciendo así:

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

Cuando esto se ejecuta, obtengo el siguiente error de aserción:

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

Sin embargo, cuando cambio mi prueba a assert.deepEqual , la prueba pasa bien. Me preguntaba si era un caso de == vs === , pero si entro

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

en la línea de comando node.js, todavía obtengo falsa.

¿Por qué las matrices no se comparan con la forma en que lo hacen otros valores (por ejemplo, 1 == 1 )? y cual es la diferencia entre assert.equal y assert.deepEqual?

Answer 1

¿Por qué las matrices no se comparan con la forma en que lo hacen otros valores (por ejemplo, 1 == 1)

Los números, cadenas, booleanos, null e undefined son valores que se comparan como cabría esperar. 1 == 1 , ''a'' == ''a'' , y así sucesivamente. La diferencia entre === y == en el caso de los valores es que == intentará realizar la conversión de tipo primero, por lo que ''1'' == 1 pero no ''1'' === 1 .

Las matrices, por otro lado, son objetos. === y == en este caso no significa que los operandos son semánticamente iguales, sino que se refieren al mismo objeto .

¿Cuál es la diferencia entre assert.equal y assert.deepEqual?

assert.equal comporta como se explicó anteriormente. En realidad, falla si los argumentos son != , Como se puede ver en la fuente . Por lo tanto, falla para sus matrices de cadenas de números porque, aunque son esencialmente equivalentes, no son el mismo objeto.

La igualdad profunda (también conocida como estructural), por otro lado, no prueba si los operandos son el mismo objeto, sino que son equivalentes. En cierto sentido, podría decirse que obliga a los objetos a compararse como si fueran valores.

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!