Welke operators bestaan er in JavaScript?

In JavaScript zijn er verschillende typen operatoren die verschillende functies uitvoeren:

Toewijzingsoperatoren: Wijs een waarde toe aan een variabele.
- = (eenvoudige toewijzing)
- +=, -=, *=, /=, %= (compound toewijzingen)
- **= (toewijzing met machtsverheffing)
- <<=, >>=, >>>= (verschuiving met toewijzing)
- &=, |=, ^= (bitwise operaties met toewijzing)
- &&=, ||=, ??= (logische toewijzing)
Vergelijkingsoperatoren: Vergelijken twee waarden en geven een boolean terug.
- == (gelijkheid)
- != (ongelijkheid)
- === (strikte gelijkheid)
- !== (strikte ongelijkheid)
- > (groter dan)
- < (kleiner dan)
- >= ( groter dan of gelijk aan)
- <= (kleiner dan of gelijk aan)
Aritmetische operatoren: Voeren wiskundige bewerkingen uit.
- + (optelling)
- - (aftrekking)
- * (vermenigvuldiging)
- / (deling)
- % (rest bij deling)
- ** (macht)
- ++ (increment)
- -- (decrement)
Bitwise operatoren: Voeren bewerkingen uit op de afzonderlijke bits van een getal.
- & (bitwise AND)
- | (bitwise OR)
- ^ (bitwise XOR)
- ~ (bitwise NOT)
- << (links verschuiven)
- >> (rechts verschuiven met behoud van teken)
- >>> (rechts verschuiven met nulvulling)
Logische operatoren: Combineren of inverteren booleaanse waarden.
- && (logisch EN)
- || (logisch OF)
- ! (logisch NIET)
Stringoperatoren: Werken met strings.
- + (concatenatie)

Voorwaardelijke (ternaire) operator: Korte vorm van if...else.

// voorwaarde ? uitdrukking1 : uitdrukking2
let resultaat = (a > b) ? "a is groter dan b" : "b is groter of gelijk aan a";

Comma operator: Voert meerdere uitdrukkingen uit en geeft de waarde van de laatste terug.
```
let x = 0;
let y = (x++, 5); // x wordt 1, y wordt 5
```

Relatieoperatoren: Controleren het type en de aanwezigheid van eigenschappen.

in (controleert of een eigenschap bestaat in een object)

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

instanceof (controleert of een object een instantie is van een klasse)

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

Unarie operatoren:
- + (zet operand om in een getal)
```
console.log(+"5"); // 5 (getal)
```
- - (zet operand om in een getal en keert teken om)
```
console.log(-"10"); // -10 (getal)
```

Type operatoren:

typeof (geeft een string terug die het type van de operand aangeeft)

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

delete (verwijdert een eigenschap van een object of een element uit een array)

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

Groeperingsoperator (): Bepaalt de volgorde van bewerkingen.

let z = (2 + 3) * 4; // Uitvoeringen binnen haakjes eerst

Nieuw operator: Maakt een nieuw object aan.

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

super operator: Roept de methode van de ouderklasse aan.

class Parent {
  greet() {
    console.log("Hello from Parent");
  }
}
class Child extends Parent {
  greet() {
    super.greet(); // oudermethode aanroepen
    console.log("Hello from Child");
  }
}

this operator: Verwijst naar de huidige uitvoeringscontext.
void operator: Voert een uitdrukking uit en geeft undefined terug.
```
// void expressie
console.log(void 0); // undefined
```
Nullish coalescing en optional chaining operatoren:
- ?? (nullish coalescing operator - geeft de rechter operand terug als de linker null of undefined is)
```
// left ?? right
let waarde = undefined ?? "standaard"; // waarde wordt "standaard"
```
- ?. (optional chaining operator - veilige toegang tot eigenschappen, zonder fout als tussenliggende waarde null of undefined is)
```
// object?.property?.method()
let gebruiker = { adres: { stad: "NYC" } };
console.log(gebruiker.adres?.zipCode); // undefined (foutloos)
```