Lección 44: Throw (Lanzar Errores)

🧠 Concepto

La instrucción throw permite lanzar errores personalizados en tu código. Puedes lanzar cualquier valor, pero por convención se usan objetos Error.

Sintaxis

throw new Error('Algo salió mal');

Tipos de error nativos

throw new Error('Error genérico');
throw new TypeError('Se esperaba un número');
throw new ReferenceError('Variable no definida');
throw new SyntaxError('Sintaxis inválida');
throw new RangeError('Valor fuera de rango');

Crear errores personalizados

class ValidacionError extends Error {
  constructor(mensaje, campo) {
    super(mensaje);
    this.name = 'ValidacionError';
    this.campo = campo;
  }
}

try {
  throw new ValidacionError('El email no es válido', 'email');
} catch (error) {
  console.log(error.name);    // "ValidacionError"
  console.log(error.message); // "El email no es válido"
  console.log(error.campo);   // "email"
}

💻 Ejemplo

// Validación con throw
function dividir(a, b) {
  if (typeof a !== 'number' || typeof b !== 'number') {
    throw new TypeError('Ambos argumentos deben ser números');
  }
  if (b === 0) {
    throw new Error('No se puede dividir por cero');
  }
  return a / b;
}

// Uso con try/catch
try {
  console.log(dividir(10, 2)); // 5
  console.log(dividir(10, 0)); // Lanza error
} catch (error) {
  if (error instanceof TypeError) {
    console.error('Error de tipo:', error.message);
  } else {
    console.error('Error:', error.message);
  }
}

// Validación de rangos
function configurarEdad(edad) {
  if (edad < 0) {
    throw new RangeError('La edad no puede ser negativa');
  }
  if (edad > 150) {
    throw new RangeError(`Edad ${edad} excede el límite realista`);
  }
  if (!Number.isInteger(edad)) {
    throw new TypeError('La edad debe ser un número entero');
  }
  return `Edad configurada: ${edad}`;
}

try {
  console.log(configurarEdad(-5));
} catch (error) {
  console.error(`${error.name}: ${error.message}`);
}

⚠️ Nota

Puedes lanzar cualquier tipo de valor, pero NO lo hagas. Lanzar strings, números u objetos genéricos dificulta el manejo de errores:

// ❌ Mal
throw 'Error';
throw 404;
throw { codigo: 500 };

// ✅ Bien
throw new Error('Algo salió mal');
throw new TypeError('Tipo incorrecto');

La decisión de cuándo lanzar errores vs manejarlos localmente:

• Lanza errores cuando la función no puede continuar y el responsable es el llamante
• Maneja errores cuando puedes recuperarte localmente (valor por defecto, reintentar, etc.)

🎯 Tip

Buenas prácticas con throw:

1. Usa tipos de error específicos (TypeError, RangeError, etc.)
2. Crea clases de error personalizadas para tu dominio
3. Siempre proporciona mensajes de error descriptivos
4. Documenta qué errores lanza tu función (JSDoc)

/**
 * Valida un email
 * @param {string} email - Email a validar
 * @throws {TypeError} Si email no es string
 * @throws {Error} Si el formato del email es inválido
 */
function validarEmail(email) {
  if (typeof email !== 'string') {
    throw new TypeError('Email debe ser string');
  }
  if (!email.includes('@')) {
    throw new Error('Email debe contener @');
  }
  return true;
}

📝 Ejercicio

Crea una función transferirBancaria que reciba monto y saldo. Debe lanzar:

• TypeError si algún argumento no es número
• RangeError si el monto es negativo o cero
• Error si el monto supera el saldo

function transferirBancaria(monto, saldo) {
  // Tu código aquí
}

try {
  transferirBancaria(100, 50); // Error: Saldo insuficiente
} catch (error) {
  console.log(`${error.name}: ${error.message}`);
}