Gli operatori in JavaScript (inclusi i bitwise)

Nel mondo della programmazione, e in particolare in JavaScript, gli operatori giocano un ruolo fondamentale. Essi sono gli strumenti che ci permettono di manipolare valori, confrontare variabili, eseguire calcoli matematici, e molto altro. Per te che stai imparando o perfezionando le tue competenze in JavaScript, è essenziale capire come e quando utilizzare questi operatori. In questo approfondimento, ti guiderò attraverso i diversi tipi di operatori presenti in JavaScript, spiegandoti le loro funzioni e fornendoti esempi pratici.

Esploreremo insieme:

• Operatori Aritmetici: fondamentali per qualsiasi calcolo matematico.
• Operatori di Assegnazione: utili per assegnare e manipolare i valori delle variabili.
• Operatori di Comparazione: essenziali per confrontare valori e variabili.
• Operatori di Tipo: per identificare il tipo di dati.
• Operatori Logici: cruciale per costruire la logica nelle tue condizioni.
• Operatori Bitwise: un po' più avanzati, operano direttamente sui bit.

Ogni sezione sarà accompagnata da esempi di codice, che ti aiuteranno a comprendere meglio come utilizzare questi operatori nella pratica. Questo approfondimento ti fornirà le basi necessarie per lavorare con maggiore confidenza e comprensione nel linguaggio JavaScript. Preparati a tuffarti nel mondo degli operatori di JavaScript!

Operatori Aritmetici

Gli operatori aritmetici ti permettono di eseguire calcoli matematici.

• Addizione (+): Somma due valori.
• Sottrazione (-): Sottrae il secondo valore dal primo.
• Moltiplicazione (*): Moltiplica due valori.
• Divisione (/): Divide il primo valore per il secondo.
• Modulo (%): Restituisce il resto di una divisione.
• Incremento (++): Aumenta il valore di una variabile di uno.
• Decremento (--): Diminuisce il valore di una variabile di uno.

1let a = 5;
2let b = 2;
3console.log(a + b); // 7
4console.log(a - b); // 3
5console.log(a * b); // 10
6console.log(a / b); // 2.5
7console.log(a % b); // 1
8a++;
9console.log(a); // 6
10b--;
11console.log(b); // 1

Operatori di Assegnazione

Gli operatori di assegnazione servono a assegnare valori alle variabili.

• Assegnazione (=): Assegna un valore.
• Assegnazione con addizione (+=): Somma e assegna.
• Assegnazione con sottrazione (-=): Sottrae e assegna.
• Altri operatori simili includono *=, /=, %=, ecc.

1let x = 10;
2x += 5; // x ora è 15
3x -= 3; // x ora è 12

Operatori di Comparazione

Servono per confrontare due valori.

• Uguaglianza (==): Controlla se i valori sono uguali.
• Identità/uguaglianza stretta (===): Controlla se i valori sono uguali e dello stesso tipo.
• Disuguaglianza (!=): Verifica se i valori sono diversi.
• Disuguaglianza stretta (!==): Verifica se i valori sono diversi o di tipo diverso.
• Maggiore di (>), minore di (<), maggiore o uguale a (>=), minore o uguale a (<=).

1let c = 5;
2let d = "5";
3console.log(c == d);  // true
4console.log(c === d); // false
5console.log(c != d);  // false
6console.log(c !== d); // true
7console.log(c > d);   // false
8console.log(c <= d);  // true

Operatori di Tipo

• typeof: Restituisce una stringa che indica il tipo di una variabile.
• instanceof: Restituisce un valore booleano che indica se è un'istanza di un oggetto specifico.

1console.log(typeof 42);        // "number"
2console.log(typeof "Hello");   // "string"

Operatori Logici

Gli operatori logici in JavaScript sono utilizzati per effettuare operazioni booleane, ovvero operazioni che restituiscono true o false. Sono estremamente utili nel controllo del flusso del programma, come nelle istruzioni condizionali (if, switch) e nei cicli (while, for). Ecco una panoramica dettagliata:

1. AND Logico (&&):

   • Questo operatore restituisce true se entrambi gli operandi sono veri.
   • È spesso usato per verificare se più condizioni sono soddisfatte contemporaneamente.
   • Esempio: if (user.isLoggedIn && user.hasAccess) {...}
   • In JavaScript, && è anche "short-circuit", significa che se il primo operando è false, il secondo non viene nemmeno valutato, perché il risultato finale sarà sicuramente false.

2. OR Logico (||):

   • Restituisce true se almeno uno degli operandi è vero.
   • È utile quando vuoi verificare che almeno una di molteplici condizioni sia soddisfatta.
   • Esempio: if (user.isAdmin || user.isModerator) {...}
   • Anche l'operatore || è "short-circuit": se il primo operando è true, il secondo non viene valutato.

3. NOT Logico (!):

   • Questo operatore inverte il valore booleano dell'operando.
   • Se l'operando è true, ! restituisce false e viceversa.
   • È spesso utilizzato per verificare se una condizione non è soddisfatta.
   • Esempio: if (!user.isLoggedIn) {...}

4. Coalescenza Null (??):

   • Introdotto nelle versioni più recenti di JavaScript, ?? restituisce il suo operando destro quando il sinistro è null o undefined, altrimenti restituisce l'operando sinistro.
   • È utile per assegnare valori di default.
   • Esempio: let displayName = user.name ?? "Guest";

5. Operatori Logici con Valori Non Booleani:

   • In JavaScript, gli operatori logici possono essere usati con valori non booleani.
   • In questi casi, seguono regole specifiche per la "verità" o "falsità" (truthiness or falsiness) dei valori.
   • Ad esempio, null, undefined, 0, NaN, e la stringa vuota ("") sono considerati falsy.
   • Esempio: if ("text" && 123) {...} restituisce true perché entrambi i valori sono truthy.

Gli operatori logici sono strumenti potenti per controllare il flusso del programma e prendere decisioni basate su diverse condizioni. La loro comprensione e corretto utilizzo sono essenziali per ogni sviluppatore JavaScript, permettendo di scrivere codice più pulito, più efficiente e più leggibile.

1let vero = true;
2let falso = false;
3console.log(vero && falso); // false
4console.log(vero || falso); // true
5console.log(!vero);         // false

Operatori Bitwise

Gli operatori bitwise operano a livello di singoli bit, che sono le unità più fondamentali di dati in informatica. In JavaScript, questi operatori trattano i loro operandi come un set di 32 bit (zeri e uni) e operano su di essi bit per bit. Questo tipo di operazione è utile in molte situazioni, in particolare per la programmazione a basso livello, come la manipolazione di file e protocolli di rete, o per ottimizzare alcune operazioni matematiche.

Ecco una panoramica più dettagliata degli operatori bitwise in JavaScript:

1. AND Bitwise (&): Questo operatore restituisce un 1 in ogni posizione in cui i corrispondenti bit di entrambi gli operandi sono 1. Ad esempio, 5 & 1 (che in binario è 0101 & 0001) restituisce 0001, ovvero 1.

2. OR Bitwise (|): Restituisce un 1 in ogni posizione in cui almeno uno dei corrispondenti bit degli operandi è 1. Per esempio, 5 | 1 (0101 | 0001) restituisce 0101, ovvero 5.

3. XOR Bitwise (^): Restituisce un 1 in ogni posizione in cui i corrispondenti bit degli operandi sono diversi. Per esempio, 5 ^ 1 (0101 ^ 0001) restituisce 0100, ovvero 4.

4. NOT Bitwise (~): Inverte i bit dell'operando. Ad esempio, ~5 (che in binario è ~0101) diventa 1010 in binario, che è -6 in decimale (a causa del complemento a due usato per rappresentare i numeri negativi).

5. Shift a Sinistra (<<): Sposta tutti i bit dell'operando a sinistra di un certo numero di posizioni. 5 << 1 (0101 << 1) diventa 1010, ovvero 10.

6. Shift a Destra (>>): Sposta tutti i bit dell'operando a destra. È importante notare che questo mantiene il segno. 5 >> 1 (0101 >> 1) diventa 0010, ovvero 2.

7. Zero-Fill Right Shift (>>>): Simile a >>, ma inserisce zeri negli spazi a sinistra e non mantiene il segno. Ad esempio, -5 >>> 1 sposta i bit a destra e inserisce uno zero, producendo un numero molto grande.

Questi operatori sono potenti ma possono essere anche fonte di confusione, specialmente se non si ha familiarità con la rappresentazione binaria dei numeri. Sono principalmente utilizzati in scenari specifici dove la manipolazione diretta dei bit è necessaria. Anche se non sono comuni come gli operatori aritmetici o logici nel quotidiano sviluppo web, una buona comprensione di essi è preziosa per qualsiasi sviluppatore JavaScript, specialmente quelli interessati alla programmazione a basso livello o al game development.

1let e = 5; // 0101 in binario
2let f = 3; // 0011 in binario
3console.log(e & f); // 1 (0101 & 0011 = 0001)
4console.log(e | f); // 7 (0101 | 0011 = 0111)
5console
6
7.log(e ^ f); // 6 (0101 ^ 0011 = 0110)
8console.log(~e);    // -6 (complemento di 0101)
9console.log(e << 1);// 10 (0101 << 1 = 1010)
10console.log(e >> 1);// 2  (0101 >> 1 = 0010)
11console.log(e >>> 1);//2  (0101 >>> 1 = 0010)