Conocer cómo tratar los errores en JavaScript es fundamental. El lenguaje nos ofrece mecanismos concretos que nos permiten gestionar errores de la aplicación. A continuación veremos cómo.

¿Por qué capturar errores?

Hay errores que son controlables y otros que pueden rompernos la aplicación si no los gestionamos. También es importante registrar información cuando ocurre un error para depurarlo posteriormente. O incluso para mostrar al usuario información coherente de un fallo inesperado.

Lanzar errores con throw

JavaScript nos permite lanzar errores explícitamente usando la palabra clave throw. Podemos lanzar cualquier tipo de dato, pero es más práctico lanzar instancias de Error o de clases que hereden de Error. Veamos un ejemplo.

function divide(a, b) {
  if (b === 0) {
    throw new Error('La división por 0 no está permitida');
  }
  return a / b;
}

En este caso, lanzamos un error si el divisor es cero. Este tipo de control es útil cuando queremos que quien invoque la función sepa que algo ha ido mal y decida qué hacer a continuación.

Capturar errores con try...catch

Una vez lanzado un error, podemos capturarlo con try...catch. Este bloque permite ejecutar un código con riesgo de error sin que el programa se detenga si ese error ocurre.

try {
  const result = divide(10, 0);
  console.log(result);
} catch (err) {
  console.error('Something went wrong:', err.message);
}

Aquí protegemos el código que podría fallar. Si divide lanza una excepción, la ejecución no se detiene y el error se captura en el bloque catch.

El bloque finally

El bloque opcional finally se ejecuta siempre, tanto si se ha producido un error como si no. Suele usarse para liberar recursos, cerrar conexiones o dejar el entorno en un estado consistente.

try {
  // código que podría fallar
} catch (err) {
  // gestión del error
} finally {
  // se ejecuta siempre
}

Errores personalizados

Podemos definir nuestras propias clases de error para representar fallos más específicos. Esto ayuda a categorizar errores según su naturaleza y a decidir cómo reaccionar.

class ValidationError extends Error {
  constructor(message) {
    super(message);
    this.name = 'ValidationError';
  }
}

function validateUsername(username) {
  if (username.length < 3) {
    throw new ValidationError('Username must be at least 3 characters long');
  }
}

Y después:

try {
  validateUsername('ab');
} catch (err) {
  if (err instanceof ValidationError) {
    console.warn('Error de validación:', err.message);
  } else {
    throw err;
  }
}

Este patrón permite distinguir errores que podemos tratar de aquellos que deben propagarse.

Algunos errores no se pueden capturar

No todos los errores se pueden capturar con try...catch. Por ejemplo:

• Errores de sintaxis.
• Errores asíncronos fuera del contexto del try.
• Errores que ocurren antes de que el try se haya evaluado.