Operatori in JavaScript

In questo articolo, spiegheremo gli operatori in JavaScript.

YouTube Video

Operatori in JavaScript

Gli operatori in JavaScript sono simboli o parole chiave utilizzati per eseguire calcoli o confronti su numeri e variabili. Esistono vari tipi di operatori, ciascuno con una funzione diversa. Ecco un riepilogo dei principali operatori:.

Operatori Aritmetici

Gli operatori aritmetici di JavaScript includono i seguenti:.

 1let a = 10; // Initialize variable 'a' with the value 10
 2let b = 3;  // Initialize variable 'b' with the value 3
 3
 4// Perform and display arithmetic operations between 'a' and 'b'
 5console.log("Addition (a + b):      ", a + b); // 13
 6console.log("Subtraction (a - b):   ", a - b); // 7
 7console.log("Multiplication (a * b):", a * b); // 30
 8console.log("Division (a / b):      ", a / b); // 3.333...
 9console.log("Modulus (a % b):       ", a % b); // 1
10
11// Demonstrate post-increment operation on 'a'
12// Output the current value of 'a' (10), then increment
13console.log("Post-increment (a++):  ", a++);
14// Display the incremented value of 'a' (11)
15console.log("Value of 'a' after increment:", a);
16
17// Demonstrate pre-increment operation on 'a'
18// Increment 'a' first (12) then output
19console.log("Pre-increment (++a):   ", ++a);
20
21// Demonstrate post-decrement operation on 'a'
22// Output the current value of 'a' (12), then decrement
23console.log("Post-decrement (a--):  ", a--);
24// Display the decremented value of 'a' (11)
25console.log("Value of 'a' after decrement:", a);
26
27// Demonstrate pre-decrement operation on 'a'
28// Decrement 'a' first (10) then output
29console.log("Pre-decrement (--a):   ", --a);

Gli operatori aritmetici eseguono operazioni matematiche di base su numeri. Oltre all'addizione e alla sottrazione, è possibile eseguire operazioni come il modulo, l'incremento e il decremento. Nota che il valore restituito dall'incremento o decremento varia a seconda che l'operatore sia posizionato prima o dopo l'operando.

Operatori di Assegnazione

Gli operatori di assegnazione di JavaScript includono i seguenti:.

 1let x = 10;
 2
 3x += 5;  // x = x + 5, so x becomes 15
 4console.log('After x += 5 : ', x);  // 15
 5
 6x -= 10;
 7console.log('After x -= 10 : ', x);  // 5
 8
 9x *= 3;
10console.log('After x *= 3 : ', x);  // 15
11
12x /= 3;
13console.log('After x /= 3 : ', x);  // 5
14
15x %= 2;
16console.log('After x %= 2 : ', x);  // 1

Gli operatori di assegnazione vengono utilizzati per assegnare valori alle variabili o aggiornare i valori delle variabili. Oltre all'assegnazione regolare, ci sono operatori di assegnazione per operazioni aritmetiche come l'addizione e il modulo.

Operatori di Confronto

Gli operatori di confronto di JavaScript includono i seguenti:.

 1console.log("5 == '5' evaluates to:", 5 == "5");   // true (because the values are equal)
 2console.log("5 === '5' evaluates to:", 5 === "5"); // false (because the types are different)
 3console.log("5 != '5' evaluates to:", 5 != "5");   // false
 4console.log("5 !== '5' evaluates to:", 5 !== "5"); // true
 5console.log("5 > 2 evaluates to:", 5 > 2);         // true
 6console.log("5 < 2 evaluates to:", 5 < 2);         // false
 7console.log("5 >= 5 evaluates to:", 5 >= 5);       // true
 8console.log("5 <= 4 evaluates to:", 5 <= 4);       // false
 9console.log("5 >= '5' evaluates to:", 5 >= "5");   // true
10console.log("5 <= '5' evaluates to:", 5 <= "5");   // true

• Gli operatori di confronto confrontano i valori e restituiscono vero o falso.
• L'operatore di uguaglianza (==) converte automaticamente tipi diversi, se necessario, prima di eseguire il confronto. L'operatore di uguaglianza rigorosa (===) non esegue alcuna conversione di tipo durante il confronto e restituisce true solo se entrambi i valori hanno lo stesso tipo e lo stesso valore. Utilizzare l'operatore di uguaglianza rigorosa (===) aiuta a prevenire bug causati da conversioni di tipo involontarie, quindi è consigliato utilizzarlo preferibilmente.

Operatori Logici

Gli operatori logici di JavaScript includono i seguenti:.

1let a = true;
2let b = false;
3
4console.log("a && b evaluates to:", a && b);  // false
5console.log("a || b evaluates to:", a || b);  // true
6console.log("!a evaluates to:", !a);          // false

Gli operatori logici vengono utilizzati quando ci sono più condizioni, per valutare combinazioni di condizioni.

Priorità degli operatori logici

In JavaScript, gli operatori logici sono generalmente valutati nell'ordine: prima NOT, poi AND e infine OR.

NOT ha la precedenza più alta

NOT è un operatore unario ed è valutato con la precedenza più alta.

1console.log(!true || false);  // false

AND ha precedenza su OR

AND ha una precedenza più alta rispetto a OR, quindi la parte AND viene valutata per prima.

1console.log(true || false && false);  // true

In questo modo, la parte AND (&&) viene valutata per prima, e il suo risultato viene passato a OR (||).

AND e OR eseguono una valutazione corta

AND e OR in JavaScript eseguono una valutazione corta. Se il risultato può essere determinato dal valore a sinistra, l'espressione a destra non viene valutata.

1let a = false && console.log("This will not be printed");
2console.log(a);  // false
3
4let b = true || console.log("This will not be printed");
5console.log(b);  // true

In entrambi i casi, console.log() non verrà eseguito.

Stabilire una precedenza esplicita

Raggruppando esplicitamente le espressioni con le parentesi, puoi evitare fraintendimenti sulla precedenza.

1console.log(true || (false && false));  // true

Differenze tra linguaggio naturale e interpretazione del programma

Quando si utilizzano operatori logici, è importante essere consapevoli delle ambiguità nel linguaggio naturale. Ad esempio, dicendo 'cane bianco o gatto' potrebbe significare sia 'un cane bianco o un gatto di qualsiasi colore' sia 'un cane bianco o un gatto bianco.'. Nel codice, apparirebbe così:.

1if (isWhite && isDog || isCat) {
2    console.log(' "A white dog" or "a cat of any color" ');
3}
4
5if (isWhite && (isDog || isCat)) {
6    console.log(' "A white dog" or "a white cat" ');
7}
8
9console.log(true || (false && false));  // true

Poiché il linguaggio naturale contiene ambiguità di questo tipo, è necessaria attenzione durante la programmazione o la progettazione.

Operatore Ternario (Operatore Condizionale)

JavaScript include un operatore ternario (operatore condizionale).

1let age = 20;
2let message = age >= 18 ? "Adult" : "Minor";
3console.log(message);  // "Adult"

È scritto nella forma condizione ? valore se vero : valore se falso.

Operatori Bitwise

Gli operatori bit a bit di JavaScript includono i seguenti.

 1let x = 0x0F & 0x0C;
 2console.log("0x0F & 0x0C evaluates to:", x, "(0x0C, 12)");  // 0x0C (12)
 3
 4x = 0x04 | 0x02;
 5console.log("0x04 | 0x02 evaluates to:", x, "(0x06, 6)");  // 0x06 (6)
 6
 7x = 0x0F ^ 0x0C;
 8console.log("0x0F ^ 0x0C evaluates to:", x, "(0x03, 3)");  // 0x03 (3)
 9
10// The inverted number is represented as a negative value
11// because JavaScript numbers are stored as signed 32-bit integers.
12x = ~0x0C;
13console.log("~0x0C evaluates to:", x, "(-13, 0xF3)");  // 0xF3 (-13)
14
15x = 0x04 << 1;
16console.log("0x04 << 1 evaluates to:", x, "(0x08, 8)");    // 0x08 (8)
17x = 0x04 >> 1;
18console.log("0x04 >> 1 evaluates to:", x, "(0x02, 2)");    // 0x02 (2)

Gli operatori bit eseguono calcoli sui numeri a livello di bit. Di solito vengono utilizzati per l'elaborazione a basso livello.

Operatori di tipo

Gli operatori di tipo di JavaScript includono i seguenti.

1console.log(typeof "Hello");  // "string"
2console.log(typeof 42);       // "number"
3
4let arr = [1, 2, 3];
5console.log("arr instanceof Array : ", arr instanceof Array); // true

Gli operatori di tipo vengono utilizzati per verificare il tipo di un valore o per convertirlo in un tipo specifico.

L'operatore typeof restituisce il tipo di una variabile.

L'operatore instanceof verifica se un oggetto appartiene a una classe specifica.

Riepilogo

• Operatori aritmetici eseguono calcoli di base.
• Operatori di assegnazione assegnano o aggiornano i valori nelle variabili.
• Operatori di confronto confrontano due valori e restituiscono true o false.
• Operatori logici valutano combinazioni di condizioni.
• Operatori ternari consentono di scrivere istruzioni condizionali in una forma più breve rispetto a if.
• Operatori bit a bit eseguono calcoli a livello di bit.
• Operatori di tipo consentono di verificare il tipo di un valore.

Puoi seguire l'articolo sopra utilizzando Visual Studio Code sul nostro canale YouTube. Controlla anche il nostro canale YouTube.

YouTube Video