Quais operadores existem em JavaScript?

Em JavaScript, existem vários tipos de operadores que desempenham diferentes funções:

Operadores de atribuição: Atribuem um valor a uma variável.
- = (atribuição simples)
- +=, -=, *=, /=, %= (atribuições compostas)
- **= (atribuição com exponenciação)
- <<=, >>=, >>>= (atribuição com deslocamento)
- &=, |=, ^= (atribuição com operações a nível de bits)
- &&=, ||=, ??= (atribuição lógica)
Operadores de comparação: Comparam dois valores e retornam um valor booleano.
- == (igualdade)
- != (diferença)
- === (igualdade estrita)
- !== (diferença estrita)
- > (maior que)
- < (menor que)
- >= (maior ou igual a)
- <= (menor ou igual a)
Operadores aritméticos: Realizam operações matemáticas.
- + (adição)
- - (subtração)
- * (multiplicação)
- / (divisão)
- % (resto da divisão)
- ** (exponenciação)
- ++ (incremento)
- -- (decremento)
Operadores a nível de bits: Realizam operações ao nível dos bits do número.
- & (AND a nível de bits)
- | (OR a nível de bits)
- ^ (XOR a nível de bits)
- ~ (complemento a nível de bits)
- << (deslocamento à esquerda)
- >> (deslocamento à direita com sinal)
- >>> (deslocamento à direita sem sinal)
Operadores lógicos: Combinam ou invertêm valores booleanos.
- && (AND lógico)
- || (OR lógico)
- ! (NÃO lógico)
Operadores de cadeia de caracteres: Trabalham com strings.
- + (concatenação)

Operador condicional (ternário): Forma abreviada de if...else.

// condição ? expressão1 : expressão2
let result = (a > b) ? "a é maior que b" : "b é maior ou igual a a";

Operador de vírgula: Executa várias expressões, retornando o valor da última.
```
let x = 0;
let y = (x++, 5); // x torna-se 1, y torna-se 5
```

Operadores de relação: Verificam o tipo e a existência de propriedades.

in (verifica se uma propriedade existe no objeto)

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

instanceof (verifica se um objeto é uma instância de uma classe)

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

Operadores unários + e -:
- + (converte o operando em número)
```
console.log(+"5"); // 5 (número)
```
- - (converte o operando em número e inverte o sinal)
```
console.log(-"10"); // -10 (número)
```

Operadores de tipo:

typeof (retorna uma string que indica o tipo do operando)

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

delete (remove uma propriedade de um objeto ou um elemento de um array)

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

Operador de agrupamento ( ): Define a ordem de execução das operações.

let z = (2 + 3) * 4; // As operações dentro dos parênteses são feitas primeiro

Operador new: Cria uma instância de um objeto.

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

Operador super: Chama um método da classe pai.

class Parent {
  greet() {
    console.log("Olá do Parent");
  }
}
class Child extends Parent {
  greet() {
    super.greet(); // Chamada do método do pai
    console.log("Olá do Child");
  }
}

Operador this: Refere-se ao contexto de execução atual.

Operador void: Executa uma expressão e retorna undefined.

// void expressão
console.log(void 0); // undefined

Operadores de nullish coalescing e encadeamento opcional:
- ?? (operador de fusão nula - retorna o operando direito se o esquerdo for null ou undefined)
```
// left ?? right
let val = undefined ?? "padrão"; // val será "padrão"
```
- ?. (operador de encadeamento opcional - acesso seguro às propriedades na cadeia, se um valor intermediário for null ou undefined)
```
// objeto?.propriedade?.método()
let user = { address: { city: "NYC" } };
console.log(user.address?.zipCode); // undefined (sem erro)
```