Welche Operatoren gibt es in JavaScript?

In JavaScript gibt es verschiedene Operatoren, die unterschiedliche Funktionen erfüllen:

Zuweisungsoperatoren: Weisen einer Variablen einen Wert zu.
- = (einfache Zuweisung)
- +=, -=, *=, /=, %= (kombinierte Zuweisungen)
- **= (Zuweisung mit Exponentiation)
- <<=, >>=, >>>= (Zuweisung mit Verschiebung)
- &=, |=, ^= (Zuweisung mit Bit-Operationen)
- &&=, ||=, ??= (logische Zuweisung)
Vergleichsoperatoren: Vergleichen zwei Werte und geben einen booleschen Wert zurück.
- == (Gleichheit)
- != (Ungleichheit)
- === (strikte Gleichheit)
- !== (strikte Ungleichheit)
- > (größer)
- < (kleiner)
- >= (größer oder gleich)
- <= (kleiner oder gleich)
Arithmetische Operatoren: Führen mathematische Operationen aus.
- + (Addition)
- - (Subtraktion)
- * (Multiplikation)
- / (Division)
- % (Rest der Division)
- ** (Potenzierung)
- ++ (Inkrement)
- -- (Dekrement)
Bitweise Operatoren: Führen Operationen auf Bit-Ebene durch.
- & (Bitweises UND)
- | (Bitweises ODER)
- ^ (Bitweises exklusives ODER)
- ~ (Bitweises NICHT)
- << (Linksverschiebung)
- >> (Rechtsverschiebung mit Vorzeichen)
- >>> (Rechtsverschiebung ohne Vorzeichen)
Logische Operatoren: Kombinieren oder invertieren boolesche Werte.
- && (Logisches UND)
- || (Logisches ODER)
- ! (Logisches NICHT)
String-Operatoren: Arbeiten mit Strings.
- + (Verkettung)

Bedingungsoperator (ternär): Kurze Form von if...else.

// Bedingung ? Ausdruck1 : Ausdruck2
let result = (a > b) ? "a ist größer als b" : "b ist größer oder gleich a";

Komma-Operator: Führt mehrere Ausdrücke aus und gibt den Wert des letzten zurück.
```
let x = 0;
let y = (x++, 5); // x wird 1, y wird 5
```

Beziehungsoperatoren: Überprüfen den Typ und die Existenz von Eigenschaften.

in (überprüft, ob eine Eigenschaft im Objekt existiert)

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

instanceof (überprüft, ob ein Objekt eine Instanz einer Klasse ist)

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

Unäre Operatoren + und -:
- + (wandelt den Operanden in eine Zahl um)
```
console.log(+"5"); // 5 (Zahl)
```
- - (wandelt den Operanden in eine Zahl um und invertiert das Vorzeichen)
```
console.log(-"10"); // -10 (Zahl)
```

Typ-Operatoren:

typeof (gibt eine Zeichenkette zurück, die den Typ des Operanden angibt)

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

delete (löscht eine Eigenschaft eines Objekts oder ein Element eines Arrays)

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

Gruppierungsoperator ( ): Bestimmt die Reihenfolge der Operationen.

let z = (2 + 3) * 4; // Operationen in Klammern werden zuerst ausgeführt

new-Operator: Erstellt eine Instanz eines Objekts.

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

super-Operator: Ruft eine Methode der Elternklasse auf.

class Parent {
  greet() {
    console.log("Hallo vom Parent");
  }
}
class Child extends Parent {
  greet() {
    super.greet(); // Aufruf der Elternmethode
    console.log("Hallo vom Child");
  }
}

this-Operator: Bezieht sich auf den aktuellen Ausführungskontext.
void-Operator: Führt einen Ausdruck aus und gibt undefined zurück.
```
// void Ausdruck
console.log(void 0); // undefined
```
Nullish coalescing und optional chaining Operatoren:
- ?? (Nullish Coalescing Operator - gibt den rechten Operanden zurück, wenn der linke null oder undefined ist)
```
// left ?? right
let val = undefined ?? "Standard"; // val wird "Standard"
```
- ?. (Optional Chaining Operator - sicherer Zugriff auf Eigenschaften in einer Kette, wenn ein Zwischenschritt null oder undefined ist)
```
// object?.property?.method()
let user = { address: { city: "NYC" } };
console.log(user.address?.zipCode); // undefined (ohne Fehler)
```