JavaScript - Operatori di Confronto

Ciao a tutti, futuri maghi di JavaScript! Oggi esploreremo il magico mondo degli operatori di confronto. Non preoccupatevi se non avete mai scritto una riga di codice prima – sarò il vostro guida amichevole in questo viaggio emozionante. Allora, afferrate le vostre bacchette (intendo, tastiere), e cominciamo!

Operatori di Confronto JavaScript

Gli operatori di confronto sono come i giudici nel mondo della programmazione. guardano due valori e decidono come si relazionano tra loro. Sono uguali? Uno è maggiore dell'altro? Questi operatori ci aiutano a prendere decisioni nel nostro codice, proprio come facciamo nella vita reale.

Diamo un'occhiata a tutti gli operatori di confronto che copriremo oggi:

Operatore	Nome	Esempio
==	Uguaglianza	x == y
!=	Disuguaglianza	x != y
===	Uguaglianza Stretta	x === y
!==	Disuguaglianza Stretta	x !== y
>	Maggiore di	x > y
>=	Maggiore o Uguale	x >= y
<	Minore di	x < y
<=	Minore o Uguale	x <= y

Come avviene il confronto?

Prima di immergerci in ogni operatore, capiamo come JavaScript confronta i valori. Non è molto diverso da come confrontiamo le cose nella vita reale!

1. Se confrontiamo numeri, è semplice. JavaScript controlla quale numero è maggiore.
2. Per le stringhe, JavaScript le confronta carattere per carattere, basandosi sui loro valori Unicode.
3. Se confrontiamo tipi diversi (come un numero e una stringa), JavaScript tenta geralmente di convertire un tipo in un altro prima di confrontare.

Ora, esaminiamo ogni operatore nel dettaglio.

Operatore di Uguaglianza (==) JavaScript

L'operatore di uguaglianza (==) controlla se due valori sono uguali, ma è un po' flessibile. Può convertire i tipi prima di confrontare. Ecco alcuni esempi:

console.log(5 == 5);     // true
console.log(5 == "5");   // true
console.log(true == 1);  // true
console.log(null == undefined);  // true

Nel primo esempio, è chiaro perché otteniamo true. Nel secondo, JavaScript converte la stringa "5" in un numero prima di confrontare. Il terzo esempio potrebbe sorprendervi – JavaScript considera true come 1 e false come 0. L'ultimo esempio mostra che null e undefined sono considerati uguali con l'operatore ==.

Operatore di Disuguaglianza (!=) JavaScript

L'operatore di disuguaglianza (!=) è come l'opposto di ==. Controlla se due valori non sono uguali.

console.log(5 != 6);     // true
console.log(5 != "5");   // false
console.log(true != 1);  // false

Come ==, anche questo operatore converte i tipi prima di confrontare.

Operatore di Uguaglianza Stretta (===) JavaScript

Ora, incontriamo l'operatore di uguaglianza stretta (===). Questo operatore è come il fratello più rigoroso dell'operatore ==. Non solo controlla il valore, ma assicura anche che i tipi siano gli stessi.

console.log(5 === 5);     // true
console.log(5 === "5");   // false
console.log(true === 1);  // false
console.log(null === undefined);  // false

Vedete come i risultati sono diversi da ==? L'operatore di uguaglianza stretta non fa alcuna conversione di tipo.

Operatore di Disuguaglianza Stretta (!==)

L'operatore di disuguaglianza stretta (!==) è l'opposto di ===. Controlla se due valori non sono uguali né nel valore né nel tipo.

console.log(5 !== 6);     // true
console.log(5 !== "5");   // true
console.log(true !== 1);  // true

Operatore Maggiore di (>) JavaScript

L'operatore maggiore di (>) controlla se il valore sinistro è maggiore del valore destro.

console.log(10 > 5);   // true
console.log(5 > 10);   // false
console.log(10 > 10);  // false
console.log("b" > "a");  // true (confronta i valori Unicode)

Ricorda, quando confronti stringhe, è basato sui loro valori Unicode, non sull'ordine alfabetico!

Operatore Maggiore o Uguale (>=)

L'operatore maggiore o uguale (>=) controlla se il valore sinistro è maggiore o uguale al valore destro.

console.log(10 >= 5);   // true
console.log(10 >= 10);  // true
console.log(5 >= 10);   // false

Operatore Minore di (<) JavaScript

L'operatore minore di (<) controlla se il valore sinistro è minore del valore destro.

console.log(5 < 10);   // true
console.log(10 < 5);   // false
console.log(10 < 10);  // false

Operatore Minore o Uguale (<=) JavaScript

L'operatore minore o uguale (<=) controlla se il valore sinistro è minore o uguale al valore destro.

console.log(5 <= 10);   // true
console.log(10 <= 10);  // true
console.log(10 <= 5);   // false

Confrontare null, undefined e NaN

Confrontare valori speciali come null, undefined, e NaN può essere tricky. Ecco alcuni esempi:

console.log(null == undefined);  // true
console.log(null === undefined);  // false
console.log(NaN == NaN);  // false
console.log(NaN === NaN);  // false
console.log(null > 0);  // false
console.log(null == 0);  // false
console.log(null >= 0);  // true

Il comportamento con null e undefined può essere sorprendente. NaN non è uguale a nulla, nemmeno a se stesso! E null nei confronti è convertito in 0, ma non nei controlli di uguaglianza.

E voilà, gente! Abbiamo intrapreso un viaggio attraverso il territorio degli operatori di confronto JavaScript. Ricorda, la pratica fa la perfezione, quindi non aver paura di sperimentare con questi operatori nel tuo codice. Buon codice!

Credits: Image by storyset