Ce operatori există în JavaScript?

În JavaScript există mai multe tipuri de operatori care îndeplinesc funcții diferite:

Operatori de atribuire: Atribuie o valoare unei variabile.
- = (atribuire simplă)
- +=, -=, *=, /=, %= (atributii compuse)
- **= (atribuire cu ridicare la putere)
- <<=, >>=, >>>= (shift cu atribuire)
- &=, |=, ^= (operații bitwise cu atribuire)
- &&=, ||=, ??= (atribuire logică)
Operatori de comparație: Compară două valori și returnează o valoare booleană.
- == (egalitate)
- != (diferit)
- === (egalitate strictă)
- !== (diferit strict)
- > (mai mare)
- < (mai mic)
- >= (mai mare sau egal)
- <= (mai mic sau egal)
Operatori aritmetici: Realizează operații matematice.
- + (adunare)
- - (scădere)
- * (multiplicare)
- / (împărțire)
- % (restul împărțirii)
- ** (ridicare la putere)
- ++ (increment)
- -- (decrement)
Operatori bitwise: Realizează operații la nivelul bitilor individuali ai unui număr.
- & (AND bitwise)
- | (OR bitwise)
- ^ (XOR bitwise)
- ~ (NOT bitwise)
- << (shift la stânga)
- >> (shift la dreapta cu păstrarea semnului)
- >>> (shift la dreapta cu umplere cu zero)
Operatori logici: Combină sau inversează valori booleene.
- && (AND logic)
- || (OR logic)
- ! (NOT logic)
Operatori de șiruri de caractere: Lucrează cu șiruri.
- + (concatenare)

Operator ternar (condițional): Forma scurtă a if...else.

// condiție ? expresie1 : expresie2
let rezultat = (a > b) ? "a este mai mare" : "b este mai mare sau egal cu a";

Operatorul virgulă: Execută mai multe expresii și returnează valoarea ultimei.
```
let x = 0;
let y = (x++, 5); // x devine 1, y devine 5
```

Operatori de relație: Verifică tipul și existența proprietăților.

in (verifică dacă o proprietate există în obiect)

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

instanceof (verifică dacă un obiect este instanța unei clase)

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

Operatori unari:
- + (convertește operandul în număr)
```
console.log(+"5"); // 5 (număr)
```
- - (convertește operandul în număr și inversează semnul)
```
console.log(-"10"); // -10 (număr)
```

Operatori de tip:

typeof (returnează un șir care indică tipul operandului)

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

delete (șterge o proprietate a unui obiect sau un element dintr-un array)

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

Operatorul de grupare (): Definește ordinea de executare a operațiilor.

let z = (2 + 3) * 4; // Operațiile din paranteze se execută primele

Operatorul new: Creează o instanță a unui obiect.

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

Operatorul super: Apelează metoda clasei părinte.

class Parinte {
  greet() {
    console.log("Hello from Parinte");
  }
}
class Copil extends Parinte {
  greet() {
    super.greet(); // apelare metodă părinte
    console.log("Hello from Copil");
  }
}

Operatorul this: Se referă la contextul curent de execuție.
Operatorul void: Execută o expresie și returnează undefined.
```
// void expresie
console.log(void 0); // undefined
```
Operatorii de coalescență nullish și chaining opțional:
- ?? (operator de coalescență nullish - returnează operandul drept dacă cel stâng este null sau undefined)
```
// left ?? right
let valoare = undefined ?? "implicit"; // valoarea va fi "implicit"
```
- ?. (operator de chaining opțional - acces sigur la proprietăți, dacă valoarea intermediară este null sau undefined, nu aruncă eroare)
```
// object?.property?.method()
let utilizator = { adresa: { oras: "NYC" } };
console.log(utilizator.adresa?.zipCode); // undefined (fără eroare)
```