Kādi operatori pastāv JavaScript?

JavaScript ir ir ir dažādi operatoru tipi, kas veic dažādas funkcijas:

Pievienošanas operatori: piešķir vērtību mainīgajam.
- = (vienkāršs piešķiršana)
- +=, -=, *=, /=, %= (komplekss piešķiršana)
- **= (pacelšana pakāpē)
- <<=, >>=, >>>= (novietojuma piešķiršana)
- &=, |=, ^= (bitu operāciju piešķiršana)
- &&=, ||=, ??= (loģiska piešķiršana)
Salīdzināšanas operatori: salīdzina divas vērtības un atgriež loģisku vērtību.
- == (vienādība)
- != (nevienādība)
- === (stingra vienādība)
- !== (stingra nevienādība)
- > (lielāks)
- < (mazāks)
- >= (lielāks vai vienāds)
- <= (mazāks vai vienāds)
Aritmētiskie operatori: veic matemātiskas operācijas.
- + (saskaitīšana)
- - (atņemšana)
- * (reizēšana)
- / (dalīšana)
- % (atlikums no dalīšanas)
- ** (pacelšana pakāpē)
- ++ (palielinājums par vienu)
- -- (samazinājums par vienu)
Bitu operatori: veic operācijas atsevišķu bitu līmenī.
- & (bitu AND)
- | (bitu OR)
- ^ (bitu ekskluzīvais OR)
- ~ (bitu NE)
- << (kreisais novietojums)
- >> (labais novietojums ar zīmi)
- >>> (labais novietojums ar nulli)
Loģiskie operatori: apvieno vai invertē loģiskas vērtības.
- && (loģiskais un)
- || (loģiskais vai)
- ! (loģiska ne)
String operatori: strādā ar virkni.
- + (konkatenācija)

Nosacījuma (ternārais) operators: īsā if...else forma.

// nosacījums ? izteiksme1 : izteiksme2
let result = (a > b) ? "a ir lielāks" : "b ir lielāks vai vienāds ar a";

Komatu operators: veic vairākas izteiksmes, atgriežot pēdējās vērtību.
```
let x = 0;
let y = (x++, 5); // x kļūst par 1, y kļūst par 5
```

Attiecības operatori: pārbauda tipu un īpašības.

in (pārbauda vai īpašība pastāv objektā)

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

instanceof (pārbauda vai objekts ir klases instances)

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

Unālie plusa un mīnus operatori:
- + (pārveido operandus skaitļos)
```
console.log(+"5"); // 5 (skaitlis)
```
- - (pārveido operandus skaitļos un invertē zīmi)
```
console.log(-"10"); // -10 (skaitlis)
```

Tipa operatori:

typeof (atgriež virkni, kas norāda operand tipa)

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

delete (dzēš objekta īpašību vai masīva elementu)

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

Grupēšanas operators ( ): nosaka operāciju izpildes kārtību.

let z = (2 + 3) * 4; // Vispirms tiek izpildīti skliaustos esošie aprēķini

Jauna objekta izveides operators: izveido objekta instanci.

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

Super operator: izsauc vecā klases metodi.

class Parent {
  greet() {
    console.log("Hello from Parent");
  }
}
class Child extends Parent {
  greet() {
    super.greet(); // vecā klases metodes izsaukšana
    console.log("Hello from Child");
  }
}

This operator: norāda uz pašreizējo izpildes kontekstu.

Void operator: izpilda izteiksmi un atgriež undefined.

// void izteiksme
console.log(void 0); // undefined

Nullish coalescing un optional chaining operatori:
- ?? (nullish coalescing operators - atgriež labo operandus, ja kreisais ir null vai undefined)
```
// left ?? right
let val = undefined ?? "default"; // val būs "default"
```
- ?. (optional chaining operators - droša piekļuve īpašībām ķēdē, ja starpposma vērtība ir null vai undefined)
```
// object?.property?.method()
let user = { address: { city: "NYC" } };
console.log(user.address?.zipCode); // undefined (bez kļūdas)
```