Controlla l'uguaglianza delle stringhe in JavaScript

1. Quando utilizzare un operatore per l’uguaglianza delle stringhe in JavaScript
2. Comprendere l’uguaglianza delle stringhe in JavaScript con esempi

In JavaScript, ci sono quattro operatori che puoi usare per controllare l’uguaglianza delle stringhe. Questi operatori sono chiamati operatori di confronto.

1. Strict equal (===): Il Strict equal (noto anche come operatore triplo uguale) controlla il valore della variabile e il suo tipo di dati. Se entrambe queste cose sono uguali, allora restituisce solo true, altrimenti restituisce false.
2. Rigoroso non uguale (!==): Questo è l’opposto di Rigoroso uguale. Se il valore o il tipo di dati non corrispondono, restituisce true; altrimenti, false.
3. Uguale (==): Il doppio segno di uguale controlla solo il valore di una variabile. Se il valore corrisponde, restituisce true, altrimenti restituisce false. Non si preoccupa del tipo di variabile.
4. Non uguale (!=): Questo è l’opposto di Uguale (==). Restituisce true solo se i valori all’interno delle variabili non corrispondono, indipendentemente dal loro tipo di dati. Se i valori corrispondono tra loro, restituisce false.

Questi operatori vengono utilizzati non solo per controllare l’uguaglianza delle stringhe, ma anche per controllare l’uguaglianza di altri tipi di dati. Di questi quattro operatori, cerchiamo di individuare il migliore per verificare l’uguaglianza delle stringhe a seconda dei casi d’uso.

Potresti aver già visto il 3° e il 4° operatore, cioè == e !=, che sono piuttosto comuni anche in altri linguaggi di programmazione. Ma il modo in cui funziona in JavaScript è leggermente diverso dagli altri linguaggi.

Quando utilizzare un operatore per l’uguaglianza delle stringhe in JavaScript

In relazione a JavaScript, di seguito sono riportati alcuni casi d’uso in cui è possibile utilizzare uno degli operatori === o ==.

• Se un valore di confronto può essere true o false, utilizzare === e non ==.
• Se un valore in confronto potrebbe essere uno di questi valori specifici (0, "", o [] – array vuoto), usa === invece di ==.
• In tutti gli altri casi, puoi tranquillamente usare ==. Non è solo sicuro, ma semplifica anche il codice e migliora la leggibilità.

Le stesse regole di cui sopra sono applicabili anche quando si utilizzano gli operatori Rigoroso non uguale (!==) e Non uguale (!=). Per saperne di più sulle regole specifiche, puoi leggere la sezione 11.9.3 della specifica ES5.

Comprendere l’uguaglianza delle stringhe in JavaScript con esempi

Prendiamo alcuni degli esempi e comprendiamo queste cose in dettaglio.

In questo esempio, abbiamo preso due variabili, nome_1 e nome_2. Entrambi prendono "adam" come valore della stringa. Ora applichiamo ciascuno degli operatori sopra e vediamo l’output che otteniamo.

Qui abbiamo usato quattro istruzioni if e else, ognuna delle quali rappresenta diversi operatori di confronto. Poiché sia ​​il valore che il tipo di dati sono gli stessi per le variabili name_1 e name_2, l’operatore triple equals o Strict equal (===) stamperà True come output. E il doppio uguale == stamperà anche True, poiché entrambe le variabili hanno gli stessi valori.

let name_1 = 'adam';
let name_2 = 'adam';

// Strict Equal
if (name_1 === name_2)
  console.log('True');
else
  console.log('False');

// Equal
if (name_1 == name_2)
  console.log('True');
else
  console.log('False');

// Strict not equal
if (name_1 !== name_2)
  console.log('True');
else
  console.log('False');

// Not equal
if (name_1 != name_2)
  console.log('True');
else
  console.log('False');

Produzione:

True
True
False
False

Quando si utilizza l’operatore Strict non uguale (!==) e non uguale (!=), entrambi stamperanno False come output poiché il valore stesso è lo stesso in entrambe le variabili.

Di seguito è riportato un altro esempio in cui confronteremo una stringa con un numero intero. Qui abbiamo una variabile str con un valore di "80", un valore stringa. Abbiamo un’altra variabile, num, che contiene un valore intero di "80". Poiché entrambe queste variabili hanno gli stessi valori con diversi tipi di dati, vediamo cosa succede quando si utilizzano i vari operatori di confronto su di esse.

let str = '80';
let num = 80;

// Strict Equal
if (str === num)
  console.log('True');
else
  console.log('False')

  // Equal
  if (str == num) console.log('True');
else console.log('False')

// Strict not equal
if (str !== num) console.log('True');
else console.log('False')

// Not equal
if (str != num) console.log('True');
else console.log('False')

Produzione:

False
True
True
False

Come nel primo esempio, abbiamo anche quattro istruzioni if e else, ognuna delle quali rappresenta diversi operatori di confronto.

Quando usiamo Strict equals o triple equals (===), otteniamo False come output. Il motivo è che il tipo di dati è diverso anche se i valori sono gli stessi. Ma quando usiamo il doppio uguale (==), otteniamo True come output perché il doppio uguale controlla solo il valore e non il tipo.

E quando usiamo Strict non uguale (!==), otteniamo True come output perché il valore della stringa "80" non è uguale al valore intero 80; pertanto, restituisce True.

Infine, l’operatore non uguale (!=) confronta solo il valore delle due variabili. I valori devono essere diversi per stampare True. Poiché i valori sono gli stessi in questo caso, restituisce False.