Operatori JavaScript

Introduzione

Un operatore prende uno o più valori (i suoi operandi) e produce un nuovo valore. In JavaScript, si usano gli operatori per eseguire operazioni aritmetiche, confrontare valori, assegnare valori alle variabili e costruire condizioni logiche. Questo capitolo tratta gli operatori utilizzati quotidianamente — assegnazione, aritmetica, confronto e concatenazione di string — spiega la coercizione di tipo che rende alcuni risultati sorprendenti e si conclude con un riferimento alla precedenza degli operatori per sapere cosa viene valutato per primo.

Alcuni termini utilizzati in tutto il capitolo:

• Operando — il valore su cui agisce un operatore. In 5 + 3, 5 e 3 sono operandi.
• Operatore unario — prende un operando (es. -x).
• Operatore binario — prende due operandi (es. x + y).
• Operatore ternario — prende tre operandi; JavaScript ne ha esattamente uno (?:).

Operatori di Assegnazione

L'operatore di assegnazione di base = memorizza un valore in una variabile. Gli operatori di assegnazione composti combinano un'operazione aritmetica con l'assegnazione, quindi x += 5 è la forma abbreviata di x = x + 5.

Operatore	Esempio	Equivalente a
=	x = 5	—
+=	x += 5	x = x + 5
-=	x -= 5	x = x - 5
*=	x *= 5	x = x * 5
/=	x /= 5	x = x / 5
%=	x %= 5	x = x % 5
**=	x **= 2	x = x ** 2

---

Nota che = è un'assegnazione, non un confronto. Per confrontare valori, usa === o == (vedi sotto).

Operatori Aritmetici in JavaScript

Operatori di Base: Addizione (+), Sottrazione (-), Moltiplicazione (*) e Divisione (/)

Questi operatori eseguono le quattro operazioni aritmetiche di base.

---

Modulo (%) ed Esponenziazione (**)

Il modulo (%) restituisce il resto di una divisione — utile per verifiche come "questo numero è pari?" (n % 2 === 0). L'esponenziazione (**) eleva un numero a una potenza.

---

Più e Meno Unari

- nega un valore, mentre il + unario converte il proprio operando in un numero — un modo rapido per trasformare una string numerica in un numero.

---

Incremento (++) e Decremento (--)

++ aggiunge 1 a una variabile e -- ne sottrae 1. La loro posizione è importante: la forma prefissa (++x) cambia il valore e restituisce quello nuovo, mentre la forma postfissa (x++) restituisce prima il vecchio valore e poi lo modifica.

---

Operatori di Confronto JavaScript

Gli operatori di confronto restituiscono sempre un valore boolean (true o false). Consulta il capitolo dedicato agli Operatori di Confronto per maggiori dettagli.

Uguaglianza Stretta (===) e Lasca (==)

L'uguaglianza stretta (===) restituisce true solo quando entrambi gli operandi hanno lo stesso tipo e lo stesso valore — non converte mai i tipi. L'uguaglianza lasca (==) effettua prima la coercizione degli operandi verso un tipo comune, poi li confronta, il che può dare risultati sorprendenti.

Le loro forme negate sono !== (disuguaglianza stretta) e != (disuguaglianza lasca).

---

Maggiore Di (>), Minore Di (<) e le Loro Forme "o Uguale"

Questi operatori confrontano l'ordinamento. Hanno anche le varianti >= (maggiore o uguale) e <= (minore o uguale).

---

Confronto di Valori Non Numerici

Con gli operatori relazionali (<, >, <=, >=), JavaScript esegue la coercizione di tipo. La regola: se entrambi gli operandi sono string, vengono confrontati carattere per carattere (alfabeticamente); altrimenti entrambi gli operandi vengono convertiti in numeri prima del confronto.

Questo spiega un risultato che a prima vista sembra sbagliato:

---

Confronti con NaN

NaN (Not-A-Number) è l'unico valore non uguale a niente, nemmeno a se stesso. Quindi === NaN non può mai essere usato per rilevarlo. Usa invece Number.isNaN().

---

Concatenazione di String e l'Operatore + Binario

Concatenare le String

In JavaScript, l'operatore + viene usato sia per l'addizione numerica che per la concatenazione di string.

---

+ Binario e Coercizione di Tipo

Quando uno degli operandi è una string, JavaScript converte anche l'altro in una string.

---

Buone Pratiche per la Concatenazione

---

Operatori Logici, Condizionali e di Tipo

JavaScript dispone di altre famiglie di operatori che hanno ciascuna un proprio capitolo. Ecco una mappa rapida per capire cosa fanno e dove approfondire.

Operatori Logici (&&, ||, !)

&& (AND), || (OR) e ! (NOT) combinano condizioni boolean. && e || sono anche in corto circuito e restituiscono uno dei loro operandi (non sempre un boolean), il che li rende comodi per valori predefiniti e guardie. Vedi Operatori Logici.

---

Operatore Condizionale (Ternario) (?:)

L'operatore ternario è un if/else compatto che restituisce un valore: condizione ? valoreSeVero : valoreSefalso. Vedi Operatori Condizionali.

---

typeof e instanceof

typeof restituisce una string che identifica il tipo di un valore. instanceof verifica se un object è stato creato da un particolare costruttore — trattato in Verifica delle Classi: instanceof.

---

Precedenza degli Operatori

Quando un'espressione combina più operatori, la precedenza decide quale viene eseguito per primo, mentre l'associatività decide l'ordine tra operatori con la stessa precedenza. Ad esempio, * ha una precedenza maggiore di +, quindi 2 + 3 * 4 vale 14, non 20.

Ecco gli operatori più comuni dalla precedenza più alta a quella più bassa:

Precedenza	Operatori	Descrizione
Massima	()	Raggruppamento
	++ -- (postfisso)	Incremento/decremento postfisso
	! + - ++ -- typeof (prefisso)	Operatori unari
	**	Esponenziazione (associativa a destra)
	* / %	Moltiplicazione, divisione, resto
	+ -	Addizione, sottrazione
	< <= > >= instanceof	Confronto relazionale
	== != === !==	Uguaglianza
	&&	AND logico
	||	OR logico
	? :	Condizionale (ternario)
Minima	= += -= …	Assegnazione (associativa a destra)

---

Riepilogo e Errori Comuni

• Usa === / !==, non == / != a meno che tu non voglia esplicitamente la coercizione di tipo.
• '2' < true è false perché gli operatori relazionali convertono gli operandi non-string in numeri (2 < 1).
• Il confronto tra string è alfabetico, quindi '10' < '9' è true anche se 10 < 9 è false.
• Verifica NaN con Number.isNaN(x) — x === NaN è sempre false.
• + è sovraccaricato: con un operando string esegue la concatenazione ('3' + 2 dà '32'); preferisci i template literal per maggiore chiarezza.
• x++ restituisce il vecchio valore, ++x quello nuovo.
• ** e = sono associativi a destra; la maggior parte degli altri operatori binari è associativa a sinistra.
• Usa le parentesi invece di memorizzare l'intera tabella di precedenza.

Esercitazione