Gli operatori sono i compagni perfetti per le variabili. Ci aiutano a confrontare il valore (e non solo) di una o più variabili. Teniamo presente che spesso questa comparazione viene chiamata espressione e solitamente è un valore Boolean true  o false .

Operatori di comparazione

Abbiamo chiuso la lezione precendente con i tipi di valore Boolean. Un ottimo modo per generare due valori Boolen è la comparazione tra valori:

var a = (3 > 2);
// Output: false

var b = (5 > 1);
// Output: true

In questo esempio i simboli >  e <  sono i classici “maggiore di” e “minore di”. Applicandoli avremo un risultato vero o falso. È possibile, naturalmente, usare la versione >=  e <=  cioè “maggiore o uguale di” e “minore o uguale di”. Nel prossimo esempio utilizziamo l’operatore !=  cioè “diverso da”:

console.log(3 != 4);
// Output: true

console.log("Luca" != "Rossi");
// Output: true

Come noterete, è possibile confrontare anche delle stringhe. Per confrontare l’uguaglianza tra due valori dobbiamo usare l’operatore ==  “uguale a”:

console.log(1 == 1);
// Output: true

C’è solo un caso in cui un valore non è uguale a se stesso, e cioè quando confrontiamo NaN  con NaN :

console.log(NaN == NaN);
// Output: false

Operatori logici

Ci sono alcune operazioni che possono essere applicate agli stessi Boolean. Javascript supporta tre tipi di operatore logico, and, or e not. Non si stricono direttamente, ma dovremmo usarli con degli operatori specifici. L’operatore &&  significa AND, ||  significa OR e l’operatore !  sta per NOT.

console.log(true && false);
// Output: false

console.log(false && false);
// Output: true

console.log(false || true);
// Output: true

console.log(true || true);
// Output: true

L’operatore ! si usa anteponendolo ad un espressione, per capovolgerla:

var prova = true;

console.log(true);
// Output: true

console.log(!true);
// Output: false

L’operatore ternario

Un operatore particolare è quello ternario. In sostanza è un operatore che testa una valore e restituisce un valore sul true  oppure un altro sul false :

console.log(true ? 1 : 2);
// Output: 1

console.log(false ? 1 : 2);
// Output: 2

Nel caso la parte sinistra sia true  il valore 1  ha la precedenza, nel caso contrario la avrà il valore 2 .

Il valore undefined e null

Esistono due tipi speciali, null  e undefined  che vengono usati per denotare l’assenza di un valore significativo. Quando un operazione non produce un valore preciso, verrà associato il valore undefined  o null . Spesso Javascript può andare in confusione su questo punto, è per questo che è importante fare del codice robusto che possa aspettarsi uno dei due tipi.

Confrontare tipi diversi

Javascript è un linguaggio a cosiddetta tipizzazione debole: ci permette cioè di usare dei valori senza specificarne il tipo e soprattutto ci permette di confrontare tipi diversi che sembrano uguali, a seconda del contesto. Lo si capisce da questo esempio:

console.log(8 * null)
// Output: 0
console.log("5" - 1)
// Output: 4
console.log("5" + 1)
// Output: 51
console.log("five" * 2)
// Output: NaN
console.log(false == 0)
// Output: true

Quando un operatore confronta tipi “sbagliati” di valore, Javascript li converte automaticamente al tipo che vuole, usando una serie di regole interne. Nel primo caso null  diventa 0, e il “5” della seconda diventa 5 (da stringa a numero). Nella terza, l’operatore + prova a concatenare anziché provare a sommare.

Quando qualcosa che “non sembra” un numero viene usato come tale, viene generato un valore NaN . Se usassimo NaN  in altre operazione otterremmo soltanto altri NaN  come risultato!

E se volessimo forzare javascript a confrontare anche il tipo di dato? Ci viene offerta la possibilità di usare gli operatori ===  che sta per “esattamente uguale” e !==  “esattamente diverso”. Usiamoli quando non siamo sicuri dei tipi di dati che confrontiamo per non avere risultati “strani”.

Quando un valore viene considerato false? I valori che contengono 0 , NaN  o stringa vuota “”  vengono considerati appunto false . Tutti gli altri casi, se forzati, vengono considerati true .

L’operatore breve

Sfruttando le peculiarità degli operatori && e || possiamo costruire un operatore veloce che seleziona un valore a seconda se esso è comparabile a true o false.

console.log(true || "ciao");
// Output: true

console.log("ciao" || "luca");
// Output: ciao

Nel caso di || , il valore alla sinistra dell’operatore viene scelto se questo è comparabile a true  o altrimenti seleziona quello a destra:

Nel secondo caso, “ciao” è comparabile a true , come abbiamo visto in precedenza. Stesso ragionamento vale per l’operatore && , ma al contrario.