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: trueCome 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: trueQuando 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: ciaoNel 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.