Quels opérateurs existent en JavaScript?

En JavaScript, il existe plusieurs types d'opérateurs qui remplissent différentes fonctions:

Opérateurs d'affectation: Attribuent une valeur à une variable.
- = (affectation simple)
- +=, -=, *=, /=, %= (affectations composées)
- **= (affectation avec puissance)
- <<=, >>=, >>>= (affectation avec décalage)
- &=, |=, ^= (affectation avec opérations bit à bit)
- &&=, ||=, ??= (affectation logique)
Opérateurs de comparaison: Comparent deux valeurs et renvoient une valeur booléenne.
- == (égalité)
- != (différence)
- === (égalité stricte)
- !== (différence stricte)
- > (plus grand)
- < (plus petit)
- >= (plus grand ou égal)
- <= (plus petit ou égal)
Opérateurs arithmétiques: Effectuent des opérations mathématiques.
- + (addition)
- - (soustraction)
- * (multiplication)
- / (division)
- % (reste de la division)
- ** (puissance)
- ++ (incrément)
- -- (décrément)
Opérateurs bit à bit: Effectuent des opérations au niveau des bits du nombre.
- & (ET bit à bit)
- | (OU bit à bit)
- ^ (XOR bit à bit)
- ~ (complément à un)
- << (décalage à gauche)
- >> (décalage à droite avec signe)
- >>> (décalage à droite sans signe)
Opérateurs logiques: Combinent ou inversent des valeurs booléennes.
- && (ET logique)
- || (OU logique)
- ! (NON logique)
Opérateurs de chaînes: Travaillent avec des chaînes de caractères.
- + (concaténation)

Opérateur conditionnel (ternaire): Forme abrégée de if...else.

// condition ? expression1 : expression2
let result = (a > b) ? "a est plus grand que b" : "b est plus grand ou égal à a";

Opérateur de virgule: Exécute plusieurs expressions, renvoyant la valeur de la dernière.
```
let x = 0;
let y = (x++, 5); // x devient 1, y devient 5
```

Opérateurs de relation: Vérifient le type et la présence de propriétés.

in (vérifie si une propriété existe dans un objet)

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

instanceof (vérifie si un objet est une instance d'une classe)

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

Opérateurs unaires + et -:
- + (convertit l'opérande en nombre)
```
console.log(+"5"); // 5 (nombre)
```
- - (convertit l'opérande en nombre et inverse le signe)
```
console.log(-"10"); // -10 (nombre)
```

Opérateurs de type:

typeof (renvoie une chaîne indiquant le type de l'opérande)

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

delete (supprime une propriété d'un objet ou un élément d'un tableau)

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

Opérateur de groupe ( ): Définit l'ordre d'exécution des opérations.

let z = (2 + 3) * 4; // Les opérations dans les parenthèses sont effectuées en premier

Opérateur new: Crée une instance d'un objet.

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

Opérateur super: Appelle une méthode de la classe parente.

class Parent {
  greet() {
    console.log("Bonjour du Parent");
  }
}
class Child extends Parent {
  greet() {
    super.greet(); // Appel de la méthode du parent
    console.log("Bonjour de l'Enfant");
  }
}

Opérateur this: Fait référence au contexte d'exécution actuel.
Opérateur void: Exécute une expression et retourne undefined.
```
// void expression
console.log(void 0); // undefined
```
Opérateurs de nullish coalescing et optional chaining:
- ?? (opérateur de fusion null - retourne l'opérande droit si le gauche est null ou undefined)
```
// left ?? right
let val = undefined ?? "par défaut"; // val sera "par défaut"
```
- ?. (opérateur de chaînage optionnel - accès sécurisé aux propriétés dans une chaîne, si une valeur intermédiaire est null ou undefined)
```
// object?.property?.method()
let user = { address: { city: "NYC" } };
console.log(user.address?.zipCode); // undefined (sans erreur)
```