TypeScript - Operatori

Ciao, futuri programmatori! Oggi ci imbarcheremo in un viaggio emozionante nel mondo degli operatori di TypeScript. Come il vostro amico insegnante di informatica del vicinato, sono qui per guidarvi in questa avventura passo per passo. Allora, mettetevi comodi e tuffiamoci!

Cos'è un Operatore?

Prima di iniziare la nostra odisssea sugli operatori di TypeScript, capiremo cos'è esattamente un operatore. Pensate agli operatori come a simboli speciali che dicono al computer di eseguire specifiche manipolazioni matematiche o logiche. Sono come le bacchette magiche della programmazione, che trasformano e combinano i nostri dati in vari modi.

Per esempio, quando vedete un segno "+" nel vostro codice, non è solo una decorazione. È un operatore che dice al computer di sommare le cose. Cool, vero?

Operatori Aritmetici

Iniziamo con gli operatori aritmetici. Questi probabilmente vi sono più familiari, poiché sono simili a quelli che avete usato in classe di matematica.

Ecco una tabella degli operatori aritmetici in TypeScript:

Operatore	Descrizione	Esempio
+	Addizione	5 + 3
-	Sottrazione	7 - 2
*	Moltiplicazione	4 * 6
/	Divisione	8 / 2
%	Modulo (resto)	9 % 4
++	Incremento	let x = 5; x++;
--	Decremento	let y = 3; y--;

Vediamo questi in azione:

let a: number = 10;
let b: number = 5;

console.log(a + b);  // Output: 15
console.log(a - b);  // Output: 5
console.log(a * b);  // Output: 50
console.log(a / b);  // Output: 2
console.log(a % b);  // Output: 0

let c: number = 7;
c++;
console.log(c);  // Output: 8

let d: number = 3;
d--;
console.log(d);  // Output: 2

In questo esempio, stiamo eseguendo varie operazioni aritmetiche sulle nostre variabili. L'operatore modulo (%) potrebbe essere nuovo per alcuni di voi. fornisce il resto dopo la divisione. Quindi, 10 % 5 è 0 perché 10 diviso per 5 lascia nessun resto.

Operatori Relazionali

Passiamo ora agli operatori relazionali. Questi vengono utilizzati per confrontare valori e restituire true o false in base al confronto.

Ecco una tabella degli operatori relazionali:

Operatore	Descrizione	Esempio
==	Uguale a	5 == 5
!=	Diverso da	5 != 3
>	Maggiore di	7 > 3
<	Minore di	2 < 8
>=	Maggiore o uguale a	5 >= 5
<=	Minore o uguale a	4 <= 4

Vediamo come funzionano:

let x: number = 5;
let y: number = 10;

console.log(x == y);  // Output: false
console.log(x != y);  // Output: true
console.log(x > y);   // Output: false
console.log(x < y);   // Output: true
console.log(x >= 5);  // Output: true
console.log(y <= 10); // Output: true

Questi operatori sono utili quando è necessario prendere decisioni nel codice basate sul confronto di valori.

Operatori Logici

Gli operatori logici vengono utilizzati per determinare la logica tra variabili o valori. Sono come Sherlock Holmes della programmazione, aiutandoci a dedurre verità da più condizioni.

Ecco una tabella degli operatori logici:

Operatore	Descrizione	Esempio
&&	AND logico	true && false
||	OR logico	true || false
!	NOT logico	!true

Vediamo questi in azione:

let isRaining: boolean = true;
let isWarm: boolean = false;

console.log(isRaining && isWarm);  // Output: false
console.log(isRaining || isWarm);  // Output: true
console.log(!isRaining);           // Output: false

In questo esempio, && restituisce true solo se entrambe le condizioni sono true. || restituisce true se almeno una condizione è true. ! nega il valore booleano.

Operatori Bitwise

Ora ci addentriamo in un territorio più avanzato. Gli operatori bitwise eseguono operazioni sulle rappresentazioni binarie dei numeri. Non preoccupatevi se questo sembra complesso - lo spiegheremo!

Ecco una tabella degli operatori bitwise:

Operatore	Descrizione	Esempio
&	AND bitwise	5 & 3
|	OR bitwise	5 | 3
^	XOR bitwise	5 ^ 3
~	NOT bitwise	~5
<<	Shift a sinistra	5 << 1
>>	Shift a destra	5 >> 1

Vediamo un esempio:

let a: number = 5;  // binario: 0101
let b: number = 3;  // binario: 0011

console.log(a & b);  // Output: 1 (binario: 0001)
console.log(a | b);  // Output: 7 (binario: 0111)
console.log(a ^ b);  // Output: 6 (binario: 0110)
console.log(~a);     // Output: -6 (binario: 1010 in complemento a due)
console.log(a << 1); // Output: 10 (binario: 1010)
console.log(a >> 1); // Output: 2 (binario: 0010)

Questi operatori lavorano sulla rappresentazione binaria dei numeri. Sono particolarmente utili nella programmazione a basso livello e in alcuni algoritmi.

Operatori di Assegnazione

Gli operatori di assegnazione vengono utilizzati per assegnare valori alle variabili. Sono come i traslocatori della programmazione, che mettono i valori nelle loro case appropriate (variabili).

Ecco una tabella degli operatori di assegnazione:

Operatore	Descrizione	Esempio
=	Assegnazione	x = 5
+=	Addizione e assegnazione	x += 3
-=	Sottrazione e assegnazione	x -= 2
*=	Moltiplicazione e assegnazione	x *= 4
/=	Divisione e assegnazione	x /= 2
%=	Modulo e assegnazione	x %= 3

Vediamo questi in azione:

let x: number = 10;

x += 5;  // equivalente a: x = x + 5
console.log(x);  // Output: 15

x -= 3;  // equivalente a: x = x - 3
console.log(x);  // Output: 12

x *= 2;  // equivalente a: x = x * 2
console.log(x);  // Output: 24

x /= 4;  // equivalente a: x = x / 4
console.log(x);  // Output: 6

x %= 4;  // equivalente a: x = x % 4
console.log(x);  // Output: 2

Questi operatori sono scorciatoie che rendono il nostro codice più conciso e leggibile.

Operatori Vari

TypeScript ha anche alcuni altri operatori che non si adattano agevolmente alle categorie precedenti.

Ecco una tabella di alcuni operatori vari:

Operatore	Descrizione	Esempio
?:	Condizionale (ternario)	condition ? expr1 : expr2
,	Comma	let x = (1, 2, 3)
delete	Elimina proprietà	delete obj.property
typeof	Tipo di variabile	typeof x
void	Valuta espressione e restituisce undefined	void(0)

Vediamo un esempio dell'operatore ternario, che è molto utile:

let age: number = 20;
let canVote: string = age >= 18 ? "Yes" : "No";
console.log(canVote);  // Output: "Yes"

Questo è un modo sintetico per scrivere una dichiarazione if-else. Se la condizione (age >= 18) è true, restituisce "Yes", altrimenti "No".

Operatori di Tipo

Infine, esploriamo alcuni operatori specifici di TypeScript che ci aiutano a lavorare con i tipi.

Ecco una tabella degli operatori di tipo:

Operatore	Descrizione	Esempio
typeof	Ottieni il tipo di una variabile	typeof x
instanceof	Controlla se un oggetto è un'istanza di una classe	obj instanceof Class
as	Affermazione di tipo	(someValue as string).toUpperCase()
	Affermazione di tipo (sinonimo)	(someValue).toUpperCase()

Vediamo un esempio:

let x: any = "Hello, TypeScript!";
let length: number = (x as string).length;
console.log(length);  // Output: 20

class Animal {}
class Dog extends Animal {}

let myPet = new Dog();
console.log(myPet instanceof Animal);  // Output: true

In questo esempio, stiamo usando l'affermazione di tipo per dire a TypeScript che sappiamo che x è una stringa, anche se è tipizzata come any. Stiamo anche usando instanceof per controllare se myPet è un'istanza della classe Animal.

Ecco tutto, ragazzi! Abbiamo compiuto un viaggio attraverso il territorio degli operatori di TypeScript. Ricordate, la pratica fa la perfezione, quindi non abbiate paura di sperimentare con questi operatori nel vostro codice. Buon divertimento con la programmazione!

Credits: Image by storyset