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

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 o no 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, aparece el siguiente error de afirmación:

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

Sin embargo, cuando cambio mi prueba a an 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 de node.js, todavía obtengo false.

¿Por qué las matrices no se comparan como otros valores (por ejemplo 1 == 1)? y ¿cuál es la diferencia entre assert.equal y assert.deepEqual?

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

Los números, cadenas, valores booleanos nully undefinedson valores y 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 ==primero intentará realizar la conversión de tipo, que es la razón '1' == 1pero no '1' === 1 .

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

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

assert.equalse comporta como se explicó anteriormente. De hecho, falla si los argumentos son !=, como 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 comparar 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!