Saltar al contenido

Sección 4: Texto, errores y depuración, 0 de 3 lecciones completadas

Lección 14 de 22Texto, errores y depuración

Errores: try, catch y throw

  • 6 min de lectura
  • 3 ejercicios

Maneja errores en JavaScript con try, catch y finally, lanza los tuyos con throw y conoce los errores más comunes: ReferenceError, TypeError y SyntaxError.

Cuando algo sale mal

Los errores son normales: un dato llega con un formato inesperado, una función recibe un valor inválido, una variable tiene un nombre mal escrito. Cuando ocurre un error que nadie maneja, JavaScript detiene el programa:

console.log("Antes");
const total = precio * 2; // ReferenceError: precio is not defined
console.log("Después");   // nunca se ejecuta

Tipos de error comunes

Error Cuándo aparece Ejemplo
ReferenceError Usas una variable que no existe console.log(nombr)
TypeError Usas un valor de una forma que su tipo no permite null.length, 5()
SyntaxError El código está mal escrito y no se puede ni empezar a ejecutar if (x {
RangeError Un número está fuera del rango permitido "a".repeat(-1)

El TypeError más frecuente de todos es este: Cannot read properties of undefined (reading 'nombre'). Significa que intentaste leer .nombre de algo que vale undefined, por ejemplo el resultado de un find que no encontró nada.

try y catch

try encierra el código que podría fallar. Si se lanza un error dentro, la ejecución salta al bloque catch, que recibe el error. El programa no se detiene:

try {
  const datos = JSON.parse("{ esto no es json }");
  console.log(datos);
} catch (error) {
  console.log("No se pudo leer: " + error.name);
}
console.log("El programa sigue");
// No se pudo leer: SyntaxError
// El programa sigue

Todo error tiene dos propiedades útiles:

  • name: el tipo, como "TypeError".
  • message: la descripción, como "x is not a function".

finally

El bloque finally se ejecuta siempre, haya error o no. Sirve para tareas de limpieza, como ocultar un indicador de «cargando»:

try {
  console.log("Procesando...");
  throw new Error("falló algo");
} catch (error) {
  console.log("Error: " + error.message);
} finally {
  console.log("Listo");
}
// Procesando...
// Error: falló algo
// Listo

Lanzar tus propios errores con throw

throw lanza un error. Úsalo cuando tu función recibe algo con lo que no puede trabajar. Es mejor fallar pronto y con un mensaje claro que devolver un resultado incorrecto en silencio:

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)); // 5
  console.log(dividir(1, 0));
} catch (error) {
  console.log(error.message); // No se puede dividir entre cero
}

Puedes lanzar tipos específicos, como new TypeError("...") o new RangeError("..."), para indicar mejor la causa.

Errores personalizados

Para distinguir tus errores de los demás, puedes crear tu propio tipo con una clase (las clases tienen su propia lección más adelante):

class ErrorDeValidacion extends Error {
  constructor(mensaje) {
    super(mensaje);
    this.name = "ErrorDeValidacion";
  }
}

try {
  throw new ErrorDeValidacion("El email es obligatorio");
} catch (error) {
  if (error instanceof ErrorDeValidacion) {
    console.log("Revisa el formulario: " + error.message);
  } else {
    throw error; // no es nuestro: lo relanzamos
  }
}

Cuándo usar try/catch

  • Sí: alrededor de operaciones que pueden fallar por causas externas, como leer JSON, pedir datos a un servidor o procesar lo que escribe el usuario.
  • No: para tapar errores de programación. Un ReferenceError por un nombre mal escrito se corrige en el código, no se captura.

Puntos clave

  • Un error no capturado detiene el programa; try/catch te permite reaccionar.
  • catch recibe el error; su propiedad message explica qué pasó.
  • finally se ejecuta siempre, haya error o no.
  • throw new Error("mensaje") lanza tus propios errores cuando algo es inválido.
  • Captura solo los errores que sabes manejar; no los escondas con un catch vacío.

Hora de practicar

Ejercicios

0/3 resueltos

Reto 1 de 3

Ejercicio 1: Leer JSON sin romper el programa

Completa leerJSON(texto) para que devuelva el resultado de JSON.parse(texto), pero si el texto no es JSON válido, debe devolver null en lugar de lanzar un error.

function leerJSON(texto) {
  // TODO: envuelve JSON.parse en try/catch y devuelve null si falla
  return JSON.parse(texto);
}

Pulsa «Ejecutar» (o Ctrl + Enter) para ver la salida.

Reto 2 de 3

Ejercicio 2: Validar con throw

Completa validarEdad(edad):

  • Si edad no es de tipo number, lanza un TypeError con el mensaje "La edad debe ser un número".
  • Si es negativa, lanza un RangeError con el mensaje "La edad no puede ser negativa".
  • Si es válida, devuelve true.
function validarEdad(edad) {
  // TODO: lanza TypeError si edad no es un número
  // TODO: lanza RangeError si edad es negativa
  return true;
}

Pulsa «Ejecutar» (o Ctrl + Enter) para ver la salida.

Reto 3 de 3

Ejercicio 3: Siempre se cierra

Completa procesar(valor) para que use try, catch y finally y produzca la salida indicada. La función tarea ya está escrita y lanza un error si el valor es negativo.

  • En try: muestra "Resultado: " seguido de tarea(valor).
  • En catch: muestra "Error: " seguido del mensaje del error.
  • En finally: muestra "Fin".

La salida debe ser:

Resultado: 10
Fin
Error: valor negativo
Fin
function tarea(valor) {
  if (valor < 0) throw new Error("valor negativo");
  return valor * 2;
}

function procesar(valor) {
  // TODO: usa try, catch y finally
  console.log("Resultado: " + tarea(valor));
}

procesar(5);
procesar(-1);

Pulsa «Ejecutar» (o Ctrl + Enter) para ver la salida.

¿Has encontrado un error en esta lección? Avísanos