Quali operatori esistono in JavaScript?

In JavaScript, ci sono diversi tipi di operatori che svolgono funzioni diverse:

Operatori di assegnazione: Assegnano un valore a una variabile.
- = (assegnazione semplice)
- +=, -=, *=, /=, %= (assegnazioni composte)
- **= (assegnazione con potenza)
- <<=, >>=, >>>= (assegnazione con shift)
- &=, |=, ^= (assegnazione con operazioni bit a bit)
- &&=, ||=, ??= (assegnazione logica)
Operatori di confronto: Confrontano due valori e restituiscono un valore booleano.
- == (uguaglianza)
- != (disuguaglianza)
- === (uguaglianza stretta)
- !== (disuguaglianza stretta)
- > (maggiore)
- < (minore)
- >= (maggiore o uguale)
- <= (minore o uguale)
Operatori aritmetici: Eseguono operazioni matematiche.
- + (somma)
- - (sottrazione)
- * (moltiplicazione)
- / (divisione)
- % (resto della divisione)
- ** (esponenziazione)
- ++ (incremento)
- -- (decremento)
Operatori bit a bit: Eseguono operazioni a livello di bit sui numeri.
- & (AND bit a bit)
- | (OR bit a bit)
- ^ (XOR bit a bit)
- ~ (complemento a uno)
- << (shift a sinistra)
- >> (shift a destra con segno)
- >>> (shift a destra senza segno)
Operatori logici: Combinano o invertiscono valori booleani.
- && (AND logico)
- || (OR logico)
- ! (NOT logico)
Operatori di stringa: Operano con le stringhe.
- + (concatenazione)

Operatore ternario (condizionale): Forma abbreviata di if...else.

// condizione ? espressione1 : espressione2
let result = (a > b) ? "a è maggiore di b" : "b è maggiore o uguale a a";

Operatore virgola: Esegue più espressioni e restituisce il valore dell'ultima.
```
let x = 0;
let y = (x++, 5); // x diventa 1, y diventa 5
```

Operatori di relazione: Verificano il tipo e l'esistenza di proprietà.

in (verifica se una proprietà esiste nell'oggetto)

// 'propertyName' in object
console.log('length' in [1, 2, 3]); // true

instanceof (verifica se un oggetto è istanza di una classe)

// object instanceof className
function Car() {}
let myCar = new Car();
console.log(myCar instanceof Car); // true

Operatori unari + e -:
- + (trasforma l'operando in numero)
```
console.log(+"5"); // 5 (numero)
```
- - (trasforma l'operando in numero e inverte il segno)
```
console.log(-"10"); // -10 (numero)
```

Operatori di tipo:

typeof (restituisce una stringa che indica il tipo dell'operando)

// typeof operand
console.log(typeof 42); // "number"
console.log(typeof "hello"); // "string"

delete (elimina una proprietà di un oggetto o un elemento di un array)

// delete object.property
// delete array[indice]
let obj = { a: 1, b: 2 };
delete obj.a;
console.log(obj); // { b: 2 }

Operatore di gruppo ( ): Definisce l'ordine di esecuzione delle operazioni.

let z = (2 + 3) * 4; // Le operazioni tra parentesi vengono eseguite prima

Operatore new: Crea un'istanza di un oggetto.

// new Constructor([arguments])
let date = new Date();

Operatore super: Chiama un metodo della classe genitore.

class Parent {
  greet() {
    console.log("Ciao dal Parent");
  }
}
class Child extends Parent {
  greet() {
    super.greet(); // Chiamata al metodo del genitore
    console.log("Ciao dal Child");
  }
}

Operatore this: Si riferisce al contesto di esecuzione corrente.
Operatore void: Esegue un'espressione e restituisce undefined.
```
// void expression
console.log(void 0); // undefined
```
Operatori di nullish coalescing e optional chaining:
- ?? (nullish coalescing operator - restituisce il secondo operando se il primo è null o undefined)
```
// left ?? right
let val = undefined ?? "predefinito"; // val sarà "predefinito"
```
- ?. (optional chaining operator - accesso sicuro alle proprietà in una catena, se un valore intermedio è null o undefined)
```
// object?.property?.method()
let user = { address: { city: "NYC" } };
console.log(user.address?.zipCode); // undefined (senza errore)
```