jasmine.matchersUtil.equals vs ===

Question

Abbiamo sviluppato un set piuttosto grande di abbinamenti personalizzati di gelsomini che aiuta a rendere il nostro codice più pulito ed evitare la duplicazione del codice. Ho notato che alcuni degli abbinamenti di jasmine personalizzati usano il test di uguaglianza === e alcuni jasmine.matchersUtil.equals. Esempio:

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 domanda:

Qual è la differenza tra jasmine.matchersUtil.equals e === test di uguaglianza e quale metodo dovrebbe essere preferito?

In altre parole, in generale, si rischia solo se si utilizza ===?

Answer 1

Per quanto ho capito, qui ci sono alcune cose che ho trovato per jasmine.matchersUtil.equals e ===:

Per definizione, === confronta le due entità in base alla sua value e type. È un operatore di confronto strict. Es:

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

(Sample scenario where +0, 0 and -0 can appear)

D'altra parte, jasmine.matchersUtil.equals è implementato sulla base del _.isEqual logica di underscorejs e test di uguaglianza basato su una logica che determina se le entità passati a esso dovrebbe essere considerato uguale anche se il loro types è diverso. Qualcosa di simile -

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

Ecco un estratto dalla repo git -

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

EDIT: vantaggio di jasmine.matchersUtil.equals() è che possiamo effettivamente realizzare i nostri collaudatori parità personalizzato in modo che alcuni scenari che si ritiene possano creare problemi possono essere evitati. Ecco un esempio di un tester uguaglianza personalizzato utilizzato con esempi di seguito -

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

alcuni scenari -

1. Supponiamo che se v'è la necessità di controllare se un testo elemento è vuoto o ha qualche valore specifico e c'è un matcher gelsomino personalizzata sviluppata per questo, allora -

   "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. Controllo della parità di oggetti è più semplice utilizzando matchers personalizzati.Per esempio:

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

3. Check for equality of element's return value with regular expressions is easier using custom matchers rather than implementing the logic using ===.

4. Comparison of constructors is easier.

5. Verification of errors is handled if an error occurrence needs to be tested by passing the error object to the custom matcher.

Abbiamo sempre utilizzato matchers personalizzati ogni volta che abbiamo saputo che ci possono essere diversi valori diversi da quelli attesi di uno ciò può verificarsi, o una qualsiasi delle condizioni di cui sopra può verificarsi. Se l'aspettativa è garantita come un valore singolo, allora usare === ha senso. Spero che sia d'aiuto.