Jaké operátory existují v JavaScriptu?

V JavaScriptu existuje několik typů operátorů, které vykonávají různé funkce:

Přiřazovací operátory: Přiřazují hodnotu proměnné.
- = (jednoduché přiřazení)
- +=, -=, *=, /=, %= (složené přiřazení)
- **= (přiřazení s mocněním)
- <<=, >>=, >>>= (posun s přiřazením)
- &=, |=, ^= (bitové operace s přiřazením)
- &&=, ||=, ??= (logické přiřazení)
Operátory porovnání: Porovnávají dvě hodnoty a vracejí booleovskou hodnotu.
- == (rovnost)
- != (nerovnost)
- === (přísná rovnost)
- !== (přísná nerovnost)
- > (větší)
- < (menší)
- >= (větší nebo rovno)
- <= (menší nebo rovno)
Aritmetické operátory: Provádějí matematické operace.
- + (sčítání)
- - (odčítání)
- * (násobení)
- / (dělení)
- % (zbytek po dělení)
- ** (umocnění)
- ++ (inkrementace)
- -- (dekrementace)
Bitové operátory: Provádějí operace na úrovni jednotlivých bitů čísla.
- & (bitové AND)
- | (bitové OR)
- ^ (bitové XOR)
- ~ (bitové NOT)
- << (posun vlevo)
- >> (posun vpravo s zachováním znaménka)
- >>> (posun vpravo s nulovým doplňováním)
Logické operátory: Spojují nebo invertují booleovské hodnoty.
- && (logické AND)
- || (logické OR)
- ! (logické NOT)
Operátory řetězců: Pracují se řetězci.
- + (konkatenace)

Ternární (podmíněný) operátor: Zkrácená forma if...else.

// podmínka ? výraz1 : výraz2
let výsledek = (a > b) ? "a je větší" : "b je větší nebo rovno a";

Operátor čárky: Spouští více výrazů a vrací hodnotu posledního.
```
let x = 0;
let y = (x++, 5); // x se stane 1, y se stane 5
```

Operátory vztahu: Kontrolují typ a přítomnost vlastností.

in (kontroluje, zda vlastnost existuje v objektu)

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

instanceof (kontroluje, zda je objekt instancí třídy)

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

Unární operátory:
- + (převádí operand na číslo)
```
console.log(+"5"); // 5 (číslo)
```
- - (převádí operand na číslo a invertuje znaménko)
```
console.log(-"10"); // -10 (číslo)
```

Typové operátory:

typeof (vrací řetězec označující typ operand)

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

delete (odstraňuje vlastnost objektu nebo prvek pole)

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

Operátor skupiny (): Určuje pořadí provádění operací.

let z = (2 + 3) * 4; // Výpočty v závorkách se provádějí první

Operátor new: Vytváří instanci objektu.

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

Operátor super: Volá metodu rodičovské třídy.

class Rodič {
  pozdrav() {
    console.log("Ahoj od Rodiče");
  }
}
class Potomek extends Rodič {
  pozdrav() {
    super.pozdrav(); // volání metody rodiče
    console.log("Ahoj od Potomka");
  }
}

Operátor this: Odkazuje na aktuální kontext provádění.

Operátor void: Spouští výraz a vrací undefined.

// void výraz
console.log(void 0); // undefined

Operátory nullish coalescing a optional chaining:
- ?? (nullish coalescing operator - vrací pravý operand, pokud levý je null nebo undefined)
```
// left ?? right
let hodnota = undefined ?? "výchozí"; // hodnota bude "výchozí"
```
- ?. (optional chaining operator - bezpečný přístup k vlastnostem, pokud je mezilehlá hodnota null nebo undefined, nevyhodí chybu)
```
// object?.property?.method()
let uživatel = { adresa: { město: "NYC" } };
console.log(uživatel.adresa?.zipCode); // undefined (bez chyby)
```