¿Qué operadores existen en JavaScript?

En JavaScript, existen varios tipos de operadores que cumplen diferentes funciones:

Operadores de asignación: Asignan un valor a una variable.
- = (asignación simple)
- +=, -=, *=, /=, %= (asignaciones compuestas)
- **= (asignación con potenciación)
- <<=, >>=, >>>= (asignación con desplazamiento)
- &=, |=, ^= (asignación con operaciones a nivel de bits)
- &&=, ||=, ??= (asignación lógica)
Operadores de comparación: Comparan dos valores y devuelven un valor booleano.
- == (igualdad)
- != (desigualdad)
- === (igualdad estricta)
- !== (desigualdad estricta)
- > (mayor que)
- < (menor que)
- >= (mayor o igual que)
- <= (menor o igual que)
Operadores aritméticos: Realizan operaciones matemáticas.
- + (suma)
- - (resta)
- * (multiplicación)
- / (división)
- % (resto de la división)
- ** (potenciación)
- ++ (incremento)
- -- (decremento)
Operadores a nivel de bits: Realizan operaciones a nivel de bits en números.
- & (AND a nivel de bits)
- | (OR a nivel de bits)
- ^ ( XOR a nivel de bits)
- ~ (complemento a nivel de bits)
- << (desplazamiento a la izquierda)
- >> (desplazamiento a la derecha con signo)
- >>> (desplazamiento a la derecha sin signo)
Operadores lógicos: Combinan o invierten valores booleanos.
- && (AND lógico)
- || (OR lógico)
- ! (NO lógico)
Operadores de cadenas: Trabajan con cadenas de texto.
- + (concatenación)

Operador condicional (ternario): Forma abreviada de if...else.

// condición ? expresión1 : expresión2
let result = (a > b) ? "a es mayor que b" : "b es mayor o igual que a";

Operador de coma: Ejecuta varias expresiones, devolviendo el valor de la última.
```
let x = 0;
let y = (x++, 5); // x se vuelve 1, y se vuelve 5
```

Operadores de relación: Verifican el tipo y la existencia de propiedades.

in (verifica si una propiedad existe en un objeto)

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

instanceof (verifica si un objeto es instancia de una clase)

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

Operadores unarios + y -:
- + (convierte el operando en número)
```
console.log(+"5"); // 5 (número)
```
- - (convierte el operando en número y invierte el signo)
```
console.log(-"10"); // -10 (número)
```

Operadores de tipo:

typeof (devuelve una cadena que indica el tipo del operando)

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

delete (elimina una propiedad de un objeto o un elemento de un array)

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

Operador de agrupación ( ): Define el orden de ejecución de las operaciones.

let z = (2 + 3) * 4; // Las operaciones en paréntesis se ejecutan primero

Operador new: Crea una instancia de un objeto.

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

Operador super: Llama a un método de la clase padre.

class Parent {
  greet() {
    console.log("Hola desde Parent");
  }
}
class Child extends Parent {
  greet() {
    super.greet(); // Llamada al método del padre
    console.log("Hola desde Child");
  }
}

Operador this: Hace referencia al contexto de ejecución actual.
Operador void: Ejecuta una expresión y devuelve undefined.
```
// void expresión
console.log(void 0); // undefined
```
Operadores de nullish coalescing y encadenamiento opcional:
- ?? (operador de fusión nula - devuelve el operando derecho si el izquierdo es null o undefined)
```
// izquierda ?? derecha
let val = undefined ?? "predeterminado"; // val será "predeterminado"
```
- ?. (operador de encadenamiento opcional - acceso seguro a propiedades en una cadena, si un valor intermedio es null o undefined)
```
// objeto?.propiedad?.metodo()
let user = { address: { city: "NYC" } };
console.log(user.address?.zipCode); // undefined (sin error)
```