Saltar al contenido
Control de flujo y errores

Errores y excepciones

Lección 4 de 414 min4 ejercicios

Los errores no son el enemigo: son avisos de que algo no salió como se esperaba. Un dato que no llegó, un número que no es número, una red caída. Saber atraparlos y lanzarlos es lo que separa un programa que se rompe de uno que reacciona.

Qué mirar en el pizarrón

Sigue el camino del error: dónde se lanza, qué líneas se saltan y adónde salta. Y fíjate en el último bloque, que se ejecuta pase lo que pase.

En el pizarrón

function dividir(a, b) {  if (b === 0) throw new Error("No se puede dividir entre cero");  return a / b;} try {  console.log(dividir(10, 2));  console.log(dividir(1, 0));  console.log("esto no se imprime");} catch (error) {  console.log("Error:", error.message);} finally {  console.log("fin");}

Pilacima

    La pila está vacía.

    Consola5

    El bloque try ("intenta") se ejecuta normalmente. dividir(10, 2) devuelve 5.

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

    Ver todos los pasos en texto
    1. Paso 1: El bloque try ("intenta") se ejecuta normalmente. dividir(10, 2) devuelve 5. Pila: vacía.
    2. Paso 2: dividir(1, 0) llega a la línea 2: como b es 0, throw lanza un error. La función se interrumpe en el acto: nunca llega al return. Pila: vacía.
    3. Paso 3: Al lanzarse un error dentro del try, el resto del bloque se salta. La línea 9 no se ejecuta. Pila: vacía.
    4. Paso 4: El error llega al catch ("atrapa"), que lo recibe en la variable error. error.message es el texto que se pasó al crearlo. El programa no se rompe: el error está controlado. Pila: vacía.
    5. Paso 5: finally se ejecuta siempre, haya error o no. Es el lugar para limpiar: cerrar un archivo, ocultar un indicador de carga… Pila: vacía.

    Los errores que ya conoces

    Un error en JavaScript es un objeto con tres datos principales: name (el tipo), message (qué pasó) y stack (dónde pasó). Ya te cruzaste con los tipos más comunes:

    Tipo Cuándo aparece Ejemplo
    SyntaxError El código está mal escrito; no llega a ejecutarse console.log("hola
    ReferenceError Usas un nombre que no existe console.log(nombreQueNoExiste)
    TypeError Usas un valor de una forma que su tipo no permite null.x, "a".toFixed()
    RangeError Un número está fuera del rango permitido new Array(-1), recursión infinita

    Cuando un error no se atrapa, el programa se detiene en esa línea y la consola lo muestra en rojo.

    try, catch y finally

    Para que un error no detenga el programa, envuelve el código que puede fallar en un try y decide qué hacer en el catch:

    try {
      const lista = null;
      console.log(lista.length);  // TypeError
    } catch (error) {
      console.log("Algo salió mal:", error.message);
      console.log("Tipo:", error.name);
    } finally {
      console.log("Esto se ejecuta siempre");
    }
    console.log("El programa sigue");
    • try: el código que puede fallar.
    • catch (error): se ejecuta solo si hubo un error, que llega en la variable. Si no lo necesitas, puedes omitirla: catch { … }.
    • finally: se ejecuta siempre, con o sin error. Ideal para limpiar.

    throw: lanzar tus propios errores

    Con throw señalas que algo está mal en tus reglas, aunque para JavaScript sea válido:

    function crearUsuario(edad) {
      if (edad < 0) {
        throw new RangeError("La edad no puede ser negativa");
      }
      return { edad };
    }
    
    try {
      crearUsuario(-5);
    } catch (error) {
      console.log(`${error.name}: ${error.message}`);
    }

    Lanza siempre un objeto Error (o uno de sus tipos), nunca un texto suelto: solo el objeto guarda el stack trace que te dice dónde ocurrió.

    Cuando tu aplicación crezca, vas a crear tus propios tipos de error con clases, como class ValidacionError extends Error {}, para distinguirlos en el catch. Lo verás en la sección de Clases.

    Encadenar errores con cause (ES2022)

    Muchas veces atrapas un error técnico y quieres lanzar uno más claro para tu programa, sin perder el original. Para eso está la opción cause:

    function leerPerfil(texto) {
      try {
        return JSON.parse(texto);
      } catch (error) {
        throw new Error("No se pudo leer el perfil", { cause: error });
      }
    }
    
    try {
      leerPerfil("{esto no es JSON}");
    } catch (error) {
      console.log(error.message);         // el mensaje claro
      console.log(error.cause.name);      // el error original: SyntaxError
    }

    Varios errores a la vez: AggregateError (ES2021)

    AggregateError agrupa varios errores en uno solo, en su propiedad errors. Lo vas a encontrar sobre todo con Promise.any, en la sección de Asincronía, cuando fallan todas las opciones:

    const error = new AggregateError(
      [new Error("Servidor A caído"), new Error("Servidor B caído")],
      "Ningún servidor respondió"
    );
    
    console.log(error.message);
    console.log(error.errors.length);
    console.log(error.errors[0].message);

    ¿Es un error? Error.isError (ES2026)

    Para comprobar si un valor es un error se usaba valor instanceof Error, pero falla con errores que vienen de otro contexto, como un <iframe> o un worker. Error.isError(valor) (ES2026) lo comprueba de forma fiable:

    const e = new TypeError("algo");
    
    if (typeof Error.isError === "function") {
      console.log(Error.isError(e));        // true
      console.log(Error.isError("algo"));   // false: un texto no es un error
    } else {
      console.log("Tu navegador todavía no tiene Error.isError");
    }

    Buenas prácticas

    • Atrapa solo lo que puedes resolver. Si no sabes qué hacer con un error, deja que suba o vuelve a lanzarlo.
    • Nunca dejes un catch vacío: el problema sigue ahí, pero ya no te enteras. Como mínimo, console.error(error).
    • Usa throw para tus reglas (datos inválidos, estados imposibles) y deja que quien llama decida.
    • Lee el error completo: tipo, mensaje y la línea del stack trace. Casi siempre dicen exactamente qué pasó.

    Resumen

    • Un error es un objeto con name, message y stack. Los tipos comunes son SyntaxError, ReferenceError, TypeError y RangeError.
    • try ejecuta, catch atrapa el error y finally se ejecuta siempre.
    • throw new Error("…") lanza tus propios errores. Lanza siempre objetos Error.
    • cause (ES2022) encadena un error nuevo con el original.
    • AggregateError (ES2021) agrupa varios errores; Error.isError (ES2026) detecta errores de forma fiable.

    ¡A practicar!

    Tu progreso se guarda en este navegador.

    Autoevaluación: Lanzar y atrapar

    Elige una respuesta en cada pregunta.

    1. ¿Cuándo se ejecuta el bloque finally?

    2. ¿Por qué conviene throw new Error("…") en lugar de throw "…"?

    3. ¿Para qué sirve new Error("…", { cause: error }) (ES2022)?

    4. ¿Qué tiene de malo un catch (error) { } vacío?

    Ordena la salida: El recorrido de un error

    Sigue el camino del error y ordena lo que aparecería en la consola.

    try {  console.log("A");  null.x;  console.log("B");} catch (e) {  console.log(e.name);} finally {  console.log("C");}console.log("D");

    Consola, de arriba abajo

    1. C
    2. D
    3. A
    4. TypeError

    Detective: Un JSON que no es JSON

    Este programa intenta leer unos datos en formato JSON y se rompe. Encuentra la línea donde salta el error y elige el arreglo correcto. Cuidado: dos de las opciones son peligrosas.

    Consola

    Leyendo datos...
    datos.js:3
    const datos = JSON.parse(texto);
                       ^
    
    SyntaxError: Expected property name or '}' in JSON at position 1 (line 1 column 2)

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

    Laboratorio: Saldo insuficiente

    Completa la función para que lance un Error si no hay saldo suficiente, y llámala dentro de un try/catch que muestre el mensaje.

    programa.jsse ejecuta mientras escribes

    $ node programa.js

    (escribe tu código: se ejecuta solo)

    Lo que debe cumplir

    • Imprime Saldo insuficiente (pendiente)
    • retirar(100, 30) sigue devolviendo 70 (pendiente)
    • retirar(10, 50) lanza un Error (no un texto suelto) (pendiente)
    • Usa try y catch (pendiente)

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