Saltar al contenido
Fundamentos del lenguaje

Operadores

Lección 9 de 914 min4 ejercicios

Los operadores son los símbolos que combinan valores: +, ===, &&… Ya usaste varios. En este tema completas la caja de herramientas con los operadores modernos que hacen el código más corto y más seguro: ??, ?. y la asignación lógica.

Qué mirar en el pizarrón

El protagonista es un stock que vale 0. Compara qué hace || y qué hace ?? con ese cero, y mira cómo ?. evita un error al leer algo que no existe.

En el pizarrón

const stock = 0;const config = {}; console.log(stock || 10);console.log(stock ?? 10);console.log(config.tema?.color); let intentos;intentos ??= 3;console.log(intentos);

Variables

  1. stocknumber · 0
  2. config→ objeto #1
  3. objeto #1{}
Consola(vacía)

stock vale 0: un valor válido (no queda nada en el almacén). config es un objeto vacío.

Con el foco aquí también puedes avanzar y retroceder con las flechas del teclado.

Ver todos los pasos en texto
  1. Paso 1: stock vale 0: un valor válido (no queda nada en el almacén). config es un objeto vacío. Variables: stock number · 0, config → objeto #1, objeto #1 {}.
  2. Paso 2: || devuelve el lado derecho si el izquierdo es falsy. Como 0 es falsy, el stock real se pierde y aparece 10. Variables: stock number · 0, config → objeto #1, objeto #1 {}.
  3. Paso 3: ?? (ES2020) solo reemplaza null y undefined. El 0 es un valor real, así que lo respeta. Variables: stock number · 0, config → objeto #1, objeto #1 {}.
  4. Paso 4: config.tema no existe. Con ?., en lugar de lanzar TypeError al pedir .color, la expresión se detiene y da undefined. Variables: stock number · 0, config → objeto #1, objeto #1 {}.
  5. Paso 5: let intentos; declara la variable sin valor: vale undefined. Variables: stock number · 0, config → objeto #1, objeto #1 {}, intentos undefined.
  6. Paso 6: intentos ??= 3 (ES2021) asigna solo si la variable vale null o undefined. Es un atajo de intentos = intentos ?? 3. Variables: stock number · 0, config → objeto #1, objeto #1 {}, intentos number · 3.
  7. Paso 7: Resultado: 3. Si intentos ya hubiera tenido un valor, aunque fuera 0, no se habría tocado. Variables: stock number · 0, config → objeto #1, objeto #1 {}, intentos number · 3.

Comparación

Operador Significa Ejemplo Resultado
=== Igual (mismo tipo y valor) 3 === 3 true
!== Distinto 3 !== "3" true
> / < Mayor / menor 5 > 3 true
>= / <= Mayor o igual / menor o igual 5 <= 5 true

Recuerda del tema anterior: usa siempre === y !==, nunca == ni !=.

Lógicos y cortocircuito

&& (y), || (o) y ! (no) combinan condiciones. Pero && y || no devuelven siempre un booleano: devuelven uno de los dos valores, y dejan de evaluar en cuanto saben la respuesta. A eso se le llama cortocircuito.

  • a && b: si a es falsy, devuelve a y ni mira b. Si no, devuelve b.
  • a || b: si a es truthy, devuelve a y ni mira b. Si no, devuelve b.
console.log(true && "sí");       // sí
console.log(0 && "nunca llego");  // 0
console.log("" || "por defecto"); // por defecto
console.log("Ana" || "Anónimo");  // Ana

const usuario = { nombre: "Ana" };
usuario && console.log("Hay usuario");  // solo se ejecuta si usuario es truthy

El ternario

condición ? valorSiVerdadero : valorSiFalso elige entre dos valores en una sola expresión. Es ideal dentro de un template literal:

const puntos = 72;
const resultado = puntos >= 60 ? "aprobado" : "suspendido";
console.log(`Has ${resultado} con ${puntos} puntos`);

No encadenes ternarios: si hay más de dos opciones, usa if o switch (sección de Control de flujo).

?? : el valor por defecto correcto

a ?? b (ES2020) devuelve b solo si a es null o undefined. A diferencia de ||, respeta los valores falsy que son válidos: 0, "" y false.

const cantidad = 0;
console.log(cantidad || 1);   // 1: ¡perdimos el 0!
console.log(cantidad ?? 1);   // 0: correcto

const apodo = null;
console.log(apodo ?? "Sin apodo");  // Sin apodo

?. : leer sin romper

El encadenamiento opcional ?. (ES2020) lee una propiedad solo si lo que tiene a la izquierda existe. Si encuentra null o undefined, se detiene y devuelve undefined en lugar de lanzar un TypeError:

const pedido = { cliente: { nombre: "Ana" } };

console.log(pedido.cliente?.nombre);        // Ana
console.log(pedido.envio?.direccion);       // undefined (sin error)
console.log(pedido.envio?.direccion ?? "Retiro en tienda");

const lista = null;
console.log(lista?.[0]);                    // undefined: también con corchetes
console.log(pedido.notificar?.());          // undefined: y con llamadas

?. y ?? se combinan muy bien: lee algo que puede faltar y pon un valor por defecto si falta.

Asignación lógica (ES2021)

Tres atajos para asignar solo en ciertos casos:

Operador Equivale a Asigna cuando…
a ??= b a = a ?? b a es null o undefined
a ||= b a = a || b a es falsy
a &&= b a = a && b a es truthy
const opciones = { tema: null, columnas: 0 };

opciones.tema ??= "claro";       // estaba en null: se asigna
opciones.columnas ??= 3;         // vale 0: se respeta
console.log(opciones);

Incremento y decremento

++ suma 1 y -- resta 1. Si van después de la variable, la expresión devuelve el valor anterior; si van antes, el nuevo:

let n = 5;
console.log(n++);  // 5: devuelve el valor viejo y después suma
console.log(n);    // 6
console.log(++n);  // 7: suma primero y devuelve el nuevo

Para evitar confusiones, úsalos solos en su propia línea (n++;) o usa n += 1.

Otros operadores útiles

  • typeof valor: el tipo, como texto (lo viste en Primitivos y objetos).
  • "clave" in objeto: ¿tiene el objeto esa propiedad?
  • objeto instanceof Clase: ¿fue creado con esa clase? (sección de Clases)
const coche = { marca: "Seat" };
console.log("marca" in coche);   // true
console.log("color" in coche);   // false

Precedencia

Cuando hay varios operadores, se aplican en un orden fijo, la precedencia. Los aritméticos van antes que las comparaciones, y las comparaciones antes que &&, que va antes que || y ??. Pero no hace falta memorizar la tabla: usa paréntesis cuando haya dudas. Además, JavaScript no te deja mezclar ?? con || o && sin paréntesis, justamente para evitar ambigüedades.

Resumen

  • Comparación con ===, !==, <, >, <=, >=.
  • && y || hacen cortocircuito y devuelven uno de los valores, no siempre un booleano.
  • El ternario c ? a : b elige entre dos valores.
  • ?? reemplaza solo null y undefined; respeta el 0 y el "".
  • ?. lee propiedades, índices o llamadas sin lanzar error si algo falta.
  • ??=, ||= y &&= (ES2021) asignan solo en el caso que indica su operador.
  • ++ y -- antes o después cambian lo que devuelve la expresión. Ante la duda, paréntesis.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Operadores modernos

Elige una respuesta en cada pregunta.

  1. ¿Qué da 0 ?? 5?

  2. Si usuario vale undefined, ¿qué da usuario?.direccion?.calle?

  3. ¿Qué hace nombre ||= "Anónimo"?

  4. const edad = 16; ¿Qué da edad >= 18 ? "adulto" : "menor"?

Ordena la salida: Lógicos, ternario y ??

Ordena los resultados tal como aparecerían en la consola.

const a = 5;console.log(a > 3 && "grande");console.log(a > 9 || "no tan grande");console.log(a % 2 === 0 ? "par" : "impar");console.log(null ?? "por defecto");console.log(typeof (a + ""));

Consola, de arriba abajo

  1. impar
  2. string
  3. grande
  4. por defecto
  5. no tan grande

Detective: Un método que no siempre está

Algunos usuarios tienen un método saludar y otros no. Este programa se rompe con los que no lo tienen. Encuentra la línea y elige dónde va el ?..

Consola

Ana
app.js:3
usuario.saludar();
        ^

TypeError: usuario.saludar is not a function

Paso 1: toca la línea de código que causa el error.

Laboratorio: Valores por defecto bien hechos

Este código tiene dos problemas: pierde el volumen 0 y se rompe porque preferencias no existe. Arréglalo con ?? y ?. para que imprima 0 oscuro es.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime 0 oscuro es (pendiente)
  • Usa ?? para los valores por defecto (pendiente)
  • Usa ?. para leer preferencias, que no existe (pendiente)
  • Ya no usa || (pendiente)

    domina-js · JavaScript en español, gratis y paso a paso.