JavaScript Operazioni di confronto delle uguaglianze


Esempio

JavaScript ha quattro diverse operazioni di confronto delle uguaglianze.

SameValue

Restituisce true se entrambi gli operandi appartengono allo stesso Tipo e hanno lo stesso valore.

Nota: il valore di un oggetto è un riferimento.

È possibile utilizzare questo algoritmo di confronto tramite Object.is (ECMAScript 6).

Esempi:

Object.is(1, 1);            // true
Object.is(+0, -0);          // false
Object.is(NaN, NaN);        // true
Object.is(true, "true");    // false
Object.is(false, 0);        // false
Object.is(null, undefined); // false
Object.is(1, "1");          // false
Object.is([], []);          // false

Questo algoritmo ha le proprietà di una relazione di equivalenza :

  • Reflexivity : Object.is(x, x) è true , per qualsiasi valore x
  • Simmetria : Object.is(x, y) è true se, e solo se, Object.is(y, x) è true , per qualsiasi valore x e y .
  • Transitività : Se Object.is(x, y) e Object.is(y, z) sono true , allora Object.is(x, z) è anche true , per tutti i valori x , y e z .

SameValueZero

Si comporta come SameValue, ma considera +0 e -0 uguali.

È possibile utilizzare questo algoritmo di confronto tramite Array.prototype.includes (ECMAScript 7).

Esempi:

[1].includes(1);            // true
[+0].includes(-0);          // true
[NaN].includes(NaN);        // true
[true].includes("true");    // false
[false].includes(0);        // false
[1].includes("1");          // false
[null].includes(undefined); // false
[[]].includes([]);          // false

Questo algoritmo ha ancora le proprietà di una relazione di equivalenza :

  • Reflexivity : [x].includes(x) è true , per qualsiasi valore x
  • Simmetria : [x].includes(y) è true se, e solo se, [y].includes(x) è true , per qualsiasi valore x e y .
  • Transitività : se [x].includes(y) e [y].includes(z) sono true , allora [x].includes(z) è anche true , per qualsiasi valore x , y e z .

Rigoroso paragone di uguaglianza

Si comporta come SameValue, ma

  • Considera +0 e -0 uguali.
  • Considera NaN diverso da qualsiasi valore, incluso se stesso

È possibile utilizzare questo algoritmo di confronto tramite l'operatore === (ECMAScript 3).

Esiste anche l'operatore !== (ECMAScript 3), che nega il risultato di === .

Esempi:

1 === 1;            // true
+0 === -0;          // true
NaN === NaN;        // false
true === "true";    // false
false === 0;        // false
1 === "1";          // false
null === undefined; // false
[] === [];          // false

Questo algoritmo ha le seguenti proprietà:

  • Simmetria : x === y è true se, e solo se, y === x is vero , for any values x and y`.
  • Transitività : se x === y y === z sono true , allora x === z è anche true , per qualsiasi valore x , y e z .

Ma non è una relazione di equivalenza perché

Confronto di uguaglianza astratta

Se entrambi gli operandi appartengono allo stesso Tipo, si comportano come il Parity Equality Comparison.

Altrimenti, li costringe come segue:

  • undefined e null sono considerati uguali
  • Quando si confronta un numero con una stringa, la stringa viene convertita in un numero
  • Quando si confronta un booleano con qualcos'altro, il booleano viene forzato a un numero
  • Quando si confronta un oggetto con un numero, una stringa o un simbolo, l'oggetto viene forzato a una primitiva

Se c'è stata una coercizione, i valori forzati vengono confrontati in modo ricorsivo. Altrimenti l'algoritmo restituisce false .

È possibile utilizzare questo algoritmo di confronto tramite l'operatore == (ECMAScript 1).

Esiste anche l'operatore != (ECMAScript 1), che nega il risultato di == .

Esempi:

1 == 1;            // true
+0 == -0;          // true
NaN == NaN;        // false
true == "true";    // false
false == 0;        // true
1 == "1";          // true
null == undefined; // true
[] == [];          // false

Questo algoritmo ha la seguente proprietà:

  • Simmetria : x == y è true se, e solo se, y == x è true , per qualsiasi valore x e y .

Ma non è una relazione di equivalenza perché