Algoritmi di uguaglianza in JavaScript

In questo articolo, sapremo cosa sono gli algoritmi di Euqlity e come possiamo usarli in JavaScript.

Cosa sono gli algoritmi di uguaglianza?

Gli algoritmi di uguaglianza sono le tecniche utilizzate da JavaScript per verificare se il primo valore è uguale al secondo valore.

Quindi ora sappiamo cosa sanno gli algoritmi di uguaglianza, facci sapere come usarli.

Esistono quattro algoritmi per verificare l'uguaglianza in JavaScript:

1. Algoritmo di uguaglianza di Loosley ( == )

2. Algoritmo di uguaglianza stretta ( === )

3. Algoritmo di uguaglianza dello stesso valore ( Object.is() )

4. Stesso valore zero

Conoscere Parliamo di ciascuno di essi passo dopo passo:

1. Algoritmo di uguaglianza libera ( == )

console.log("1" == 1) // true
console.log(false == 0) // true

Quindi l' operatore di uguaglianza == rende Type Coercion in cui lo usiamo e per questo motivo l'abbiamo chiamato Loosely Equality Operator .

2. Algoritmo di uguaglianza stretta ( === )

Questo parametro di uguaglianza si comporta come il precedente, l'unica differenza è che non effettua alcun tipo di conversione nei valori, quindi ti dà la cosa esatta che desideri e per questo motivo dovresti usare questo parametro di uguaglianza invece di Loosly Parametro di uguaglianza.

Quindi se ripetiamo l'esempio precedente con il parametro === questo sarà il risultato:

console.log("1" === 1) // false
console.log(false === 0) // false

console.log(1 === 1) // true
console.log(false === false) // true

In JavaScript che ti consente di verificare se il primo valore è lo stesso altro valore.

Ma Aspetta…Non è ` === ` L'operatore fa la stessa cosa

Sei sicuro?? Vediamo prima il seguente esempio:

console.log(NaN === NaN) // false

Controlla se il primo valore ha lo stesso valore del secondo valore.

Quindi, se abbiamo ripetuto l'esempio precedente con ` Object.is() ` otterremo i risultati desiderabili

console.log(NaN === NaN) // false

Object.is(-0, +0) // false 
console.log(-0 === +0) //true

// ---

Object.is(NaN, NaN) // true
console.log(NaN === NaN) // false

// ---

const obj1 = {name: "Ahmed", age: 22}
const obj2 = {name: "Ahmed", age: 22}

console.log(Object.is(obj1, obj2)) // false
console.log(obj1 === obj2) // false

/* 
  In this example two methods gave the same result but there are different
  in there tichneeques:

  [1] === when compare Objects checks if the two Objects refer to the same Reference
  [2] Object.is() when compare Objects checks if the two Objects have the same values
*/

4. Algoritmo Uguaglianza Stesso Valore Zero

Il nome dell'algoritmo si spiega da solo, questo algoritmo è identico al precedente tranne per il fatto che i valori +0 e -0 o NaN sono considerati uguali, quindi implementiamolo:

function sameValueZero(x, y) {
  if (typeof x === "number" && typeof y === "number") {
    // x and y are equal (may be -0 and 0) or they are both NaN
    return x === y || (x !== x && y !== y);
  }
  return x === y;
}

Per riassumere l'articolo. Non dovresti usare vagamente l'uguaglianza, invece puoi usare l'uguaglianza rigorosa.

È possibile utilizzare lo stesso valore o gli stessi algoritmi di valore zero nel caso in cui sia necessario eseguire attività specifiche come verificare se il valore accettato è +0 o -0 zero ... ecc.

Spero che questo articolo ti sia piaciuto e ne abbia beneficiato anche solo dell'1 percento, finalmente ci vediamo nel prossimo articolo...