Operatori in TypeScript

Questo articolo spiega gli operatori in TypeScript.

YouTube Video

Operatori in TypeScript

Gli operatori in TypeScript vengono utilizzati per eseguire calcoli numerici, confronti di valori e operazioni logiche. Poiché TypeScript utilizza operatori simili a JavaScript, sono facili da imparare, ma TypeScript permette operazioni più rigorose grazie alla sicurezza dei tipi.

Gli operatori principali sono i seguenti:.

Operatori Aritmetici

Gli operatori aritmetici vengono utilizzati per i calcoli numerici.

 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);

Operatori di Assegnazione

Gli operatori di assegnazione assegnano il valore a destra alla variabile a sinistra.

1let z = 5;
2z += 3;
3console.log(z);  // Outputs: 8
4
5z *= 2;
6console.log(z);  // Outputs: 16

Operatori di Confronto

Gli operatori di confronto confrontano i valori e restituiscono true o false.

1console.log('5 == "5"   :', 5 == "5");   // Outputs: true
2console.log('5 === "5"  :', 5 === "5");  // Outputs: false
3console.log('5 != "5"   :', 5 != "5");   // Outputs: false
4console.log('5 !== "5"  :', 5 !== "5");  // Outputs: true
5console.log('5 > 3      :', 5 > 3);      // Outputs: true
6console.log('5 < 3      :', 5 < 3);      // Outputs: false
7console.log('5 >= 5     :', 5 >= 5);     // Outputs: true
8console.log('5 <= 3     :', 5 <= 3);     // Outputs: false

Operatori Logici

Gli operatori logici vengono utilizzati per combinare espressioni logiche.

1console.log('true && false :', true && false);  // Outputs: false
2console.log('true || false :', true || false);  // Outputs: true
3console.log('!true         :', !true);          // Outputs: false

Precedenza degli operatori logici

In TypeScript, gli operatori logici vengono solitamente 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

Di conseguenza, la parte AND (&&) viene calcolata per prima e il suo risultato viene passato a OR (||).

AND e OR eseguono una valutazione con cortocircuito

In TypeScript, AND e OR eseguono una valutazione con cortocircuito. Se il risultato è determinato dal valore sul lato sinistro, l'espressione sul lato destro 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 viene eseguito.

Definire esplicitamente la precedenza

Utilizzare le parentesi per raggruppare esplicitamente le espressioni può prevenire fraintendimenti sulla precedenza.

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

Differenze tra linguaggio naturale e interpretazione nei programmi

Quando si utilizzano operatori logici, è importante essere consapevoli delle ambiguità del linguaggio naturale. Ad esempio, nella frase 'un cane bianco o un gatto', potrebbe significare sia 'un cane bianco o qualsiasi gatto', sia 'un cane bianco o un gatto bianco.'. Nel codice, può essere scritto come segue:.

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}

Poiché il linguaggio naturale può essere ambiguo, è necessaria cautela durante la programmazione e la progettazione dei sistemi.

Operatori Bitwise

Gli operatori bitwise manipolano i numeri a livello di bit.

1console.log('5 & 1  :', 5 & 1);   // Outputs: 1  (AND operation)
2console.log('5 | 1  :', 5 | 1);   // Outputs: 5  (OR operation)
3console.log('5 ^ 1  :', 5 ^ 1);   // Outputs: 4  (XOR operation)
4console.log('~5     :', ~5);      // Outputs: -6 (NOT operation)
5console.log('5 << 1 :', 5 << 1);  // Outputs: 10 (Left shift operation)
6console.log('5 >> 1 :', 5 >> 1);  // Outputs: 2  (Right shift operation)
7console.log('5 >>> 1:', 5 >>> 1); // Outputs: 2  (Unsigned right shift operation)

Operatore Ternario

L'operatore ternario restituisce valori diversi in base al risultato di un'espressione condizionale.

1let age = 20;
2let access = (age >= 18) ? "Allowed" : "Denied";
3console.log(access);  // Outputs: Allowed

Operatori di Tipo

Gli operatori di tipo di TypeScript includono i seguenti:.

 1console.log(typeof "Hello");  // "string"
 2console.log(typeof 42);       // "number"
 3
 4let arr: number[] = [1, 2, 3];
 5console.log("arr instanceof Array : ", arr instanceof Array); // true
 6
 7// Example of Type Guard
 8function isString(value: any): value is string {
 9  return typeof value === "string";
10}
11
12let value: any = "Hello";
13if (isString(value)) {
14  console.log("Value is a string:", value);  // "Value is a string: Hello"
15}

Gli operatori di tipo vengono utilizzati per verificare il tipo di un valore o 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.
• L'operatore is viene utilizzato per verificare se un valore è di un tipo specifico. Fa parte delle guardie di tipo di TypeScript.

Riepilogo

• Operatori Aritmetici: Eseguono calcoli di base.
• Operatori di Assegnazione: Assegnano valori alle variabili.
• Operatori di Confronto: Confrontano valori.
• Operatori Logici: Combinano condizioni logiche.
• Operatori a Livello di Bit: Eseguono operazioni a livello di bit.
• Operatore Ternario: Restituisce valori in base alle condizioni.
• Gli operatori di tipo possono verificare il tipo di un valore.

In TypeScript, questi operatori possono essere utilizzati per scrivere calcoli complessi ed espressioni condizionali in modo efficiente.

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

YouTube Video