javascript - diferencia - jasmine.matchersUtil.equals vs===

operadores de comparacion javascript

Question

Hemos desarrollado un conjunto bastante grande de adaptadores de jazmín personalizados que ayudan a que nuestro código sea más limpio y evitan la duplicación de código. Me he dado cuenta de que algunos de los matchers de jazmín personalizados usan === pruebas de igualdad y algunos jasmine.matchersUtil.equals . Ejemplo:

toHaveHandCursor: function() {
    return {
        compare: function(actual) {
            return {
                pass: actual.getCssValue("cursor").then(function(cursor) {
                    return cursor === "pointer";
                })
            };
        }
    };
},

toBeActive: function() {
    return {
        compare: function(elm) {
            return {
                pass: protractor.promise.all([
                    elm.getId(),
                    browser.driver.switchTo().activeElement().getId()
                ]).then(helpers.spread(function (currentElementID, activeElementID) {
                    return jasmine.matchersUtil.equals(currentElementID, activeElementID);
                })),
                message: "Element is not active."
            };
        }
    };
}

La pregunta:

¿Cuál es la diferencia entre jasmine.matchersUtil.equals y === igualdad de pruebas y qué método debe preferirse?

En otras palabras, en general, ¿nos arriesgamos si solo utilizamos === ?

Answer 1

Por lo que yo entiendo, aquí hay algunas cosas que encontré para jasmine.matchersUtil.equals y === :

Por definición, === compara las dos entidades según su value y type . Es un operador strict comparación. Por ejemplo:

2 === 2 //true
2 === 3 //false
2 === ''2'' //false
0 === -0 //true 

(Escenario de muestra donde pueden aparecer +0, 0 y -0)

Por otro lado, jasmine.matchersUtil.equals se implementa en base a la lógica _.isEqual de underscorejs y prueba la igualdad en función de una lógica que determina si las entidades que se le pasan se deben considerar iguales aunque sus types sean diferentes. Algo como esto -

jasmine.matchersUtil.equals(2, 2) //true
jasmine.matchersUtil.equals(2, 3) //false
jasmine.matchersUtil.equals(2, ''2'') //false
jasmine.matchersUtil.equals(0, -0) //false

Aquí hay un extracto del informe de git:

// Identical objects are equal. `0 === -0`, but they aren''t identical.
if (a === b) { return a !== 0 || 1 / a == 1 / b; }

EDITAR: La ventaja añadida de jasmine.matchersUtil.equals() es que realmente podemos implementar nuestros propios evaluadores de igualdad personalizados, por lo que se pueden evitar algunos escenarios que crean problemas. Aquí hay una muestra de un probador de igualdad personalizado que se utiliza con los ejemplos a continuación:

var customTester = function(first, second) {
    return first == second;
};

Pocos escenarios -

1. Supongamos que hay una necesidad de verificar si el texto de un elemento está vacío o tiene algún valor específico y hay un evaluador de jazmín personalizado desarrollado para él, entonces:

   "5" === 5 //if operation on elem returns "5" then custom matcher gives false
   jasmine.matchersUtil.equals("5", 5, customTester) //true when implemented with custom equality testers
   
   undefined === null //if operation on elem returns undefined then custom matcher gives false
   jasmine.matchersUtil.equals("", null, customTester) //true when implemented with custom equality testers
   
   NaN === NaN //if operation on elem returns NaN then custom matcher gives false
   jasmine.matchersUtil.equals(NaN, NaN) //true

2. Comprobar la igualdad de los objetos es más fácil usando los mezcladores personalizados. Por ejemplo:

   {name: ''hill''} === {name: ''hill''} //false
   jasmine.matchersUtil.equals({name: ''hill''}, {name: ''hill''}) //true

3. Comprobar la igualdad del valor de retorno del elemento con expresiones regulares es más fácil usando los mezcladores personalizados en lugar de implementar la lógica con === .

4. La comparación de constructores es más fácil.

5. La verificación de errores se maneja si se debe probar una ocurrencia de error pasando el objeto de error al emparejador personalizado.

Siempre usamos combinaciones personalizadas siempre que sabíamos que puede haber diferentes valores distintos a los esperados que pueden surgir, o puede ocurrir cualquiera de las condiciones anteriores. Si se garantiza que la expectativa es un valor único, entonces usar === tiene sentido. Espero eso ayude.