JavaScript
Revisa las clases nativas Error, TypeError, RangeError, ReferenceError, SyntaxError, URIError y AggregateError, además de cause y errores de dominio.
JavaScript incluye varias clases de error. Cada una comunica una categoría diferente de problema.
throw new TypeError(
"Price must be a number",
);Error
├── EvalError
├── RangeError
├── ReferenceError
├── SyntaxError
├── TypeError
├── URIError
└── AggregateErrorLas clases nativas heredan comportamiento de Error.
const error = new TypeError("Invalid value");
error instanceof TypeError; // true
error instanceof Error; // trueEs la clase general cuando una categoría más concreta no representa mejor el problema.
throw new Error(
"Order cannot be completed",
);Puede ser suficiente para una aplicación pequeña. En una API pública o un dominio importante, un error personalizado suele comunicar mejor el contrato.
Indica que un valor no tiene el tipo, forma o capacidad requerida para una operación.
El lenguaje puede producirlo:
const user = null;
user.name;
// TypeErrorTambién puedes utilizarlo para contratos de funciones:
function calculateTotal(prices) {
if (!Array.isArray(prices)) {
throw new TypeError(
"prices must be an array",
);
}
return prices.reduce(
(total, price) => total + price,
0,
);
}Un TypeError no significa únicamente que typeof produjo un valor distinto. También puede indicar que un objeto carece del comportamiento esperado.
function execute(callback) {
if (typeof callback !== "function") {
throw new TypeError(
"callback must be a function",
);
}
callback();
}Indica que el tipo general es válido, pero el valor está fuera del rango permitido.
function setVolume(volume) {
if (!Number.isFinite(volume)) {
throw new TypeError(
"volume must be a finite number",
);
}
if (volume < 0 || volume > 100) {
throw new RangeError(
"volume must be between 0 and 100",
);
}
}Primero se comprueba el tipo o la forma; después el rango.
El motor también utiliza RangeError:
new Array(-1);
// RangeErrorY cuando se supera el tamaño del Call Stack:
function recurse() {
recurse();
}
recurse();
// Normalmente RangeError.El mensaje exacto depende del runtime.
Indica que JavaScript no puede resolver un nombre o que un binding todavía no está disponible.
console.log(missingVariable);
// ReferenceErrorTambién ocurre en la Temporal Dead Zone.
console.log(count);
const count = 1;
// ReferenceErrorNo es lo mismo que leer una propiedad inexistente.
const user = {};
user.name; // undefinedEl objeto existe; simplemente no tiene esa propiedad.
Indica que una entrada no cumple una gramática esperada.
El parser del lenguaje puede producirlo:
const = 10;
// SyntaxError antes de ejecutar.Una API también puede lanzarlo al interpretar otro formato.
JSON.parse("not json");
// SyntaxErrorAunque se produce durante ejecución, el problema está en la sintaxis del texto JSON.
Se utiliza en operaciones de codificación y decodificación de URI.
decodeURIComponent("%E0%A4%A");
// URIErrorEs menos frecuente en código cotidiano, pero representa una entrada URI inválida.
Permanece por compatibilidad histórica. JavaScript moderno casi nunca lo lanza automáticamente.
new EvalError("Evaluation failed");No necesitas usarlo únicamente porque una operación evalúa algo. Además, eval normalmente debe evitarse por seguridad, optimización y claridad.
Representa varios errores dentro de un único fallo.
const errors = [
new Error("Email failed"),
new Error("SMS failed"),
];
throw new AggregateError(
errors,
"All notifications failed",
);La colección está disponible en:
error.errors;Promise.any rechaza con AggregateError cuando todas las promesas son rechazadas. El comportamiento completo se estudiará en asincronía.
También puede ser útil para validar varios campos o ejecutar varias operaciones independientes cuando necesitas conservar todas las causas.
const error = new TypeError("Invalid");
error.name; // "TypeError"
error.constructor === TypeError; // truePara decisiones normales suele preferirse instanceof.
if (error instanceof TypeError) {
// ...
}Sin embargo, objetos provenientes de otro realm —por ejemplo, ciertos iframes— pueden tener constructores distintos aunque representen el mismo tipo conceptual. En fronteras públicas puede ser útil combinar clases propias con códigos estables.
Los constructores de errores modernos aceptan una causa.
try {
JSON.parse(content);
} catch (cause) {
throw new Error(
"Cannot read configuration",
{ cause },
);
}El nuevo error explica el nivel actual sin perder el fallo original.
error.cause;No concatena automáticamente todos los mensajes ni decide cómo registrarlos. Conserva la relación de causalidad como dato.
const error = new Error("Failed");
console.log(error.stack);Los runtimes habituales ofrecen stack, pero su formato y contenido pueden variar. Úsala para diagnóstico, no para parsear reglas de negocio.
Error.captureStackTrace es una extensión conocida de motores basados en V8, no una API portable de ECMAScript.
if (typeof Error.captureStackTrace === "function") {
Error.captureStackTrace(error, helperFunction);
}Solo debe utilizarse cuando el runtime objetivo esté claro.
throw new TypeError(
"customerId must be a string",
);Comunica un contrato técnico.
throw new InsufficientStockError({
productId,
requested,
available,
});Comunica una regla de negocio.
No intentes representar todos los problemas del dominio con las clases nativas. Su propósito principal es describir categorías generales del lenguaje y sus APIs.
Una capa de infraestructura puede producir:
new Error("ECONNREFUSED 127.0.0.1:5432");El dominio puede traducirlo:
throw new RepositoryUnavailableError(
"Products cannot be loaded",
{ cause },
);El consumidor recibe una abstracción útil y el diagnóstico conserva la causa original.
function parsePage(value) {
const page = Number(value);
if (!Number.isInteger(page)) {
throw new TypeError(
"page must be an integer",
);
}
if (page < 1) {
throw new RangeError(
"page must be greater than zero",
);
}
return page;
}Los dos errores permiten distinguir una forma inválida de un número fuera del rango permitido.
Error para todo aunque una categoría nativa sea más clara.TypeError para cualquier regla de negocio.ReferenceError.message.EvalError es común en JavaScript moderno.AggregateError combine mensajes automáticamente.stack como formato estable.cause.Error.captureStackTrace en runtimes no compatibles.TypeError describe un tipo, forma o capacidad incorrecta.RangeError describe un valor válido en naturaleza, pero fuera del rango.ReferenceError aparece cuando un nombre no puede resolverse.SyntaxError representa una gramática inválida.URIError pertenece a operaciones de URI.EvalError es principalmente histórico.AggregateError reúne múltiples fallos.Error.cause conserva el error original al añadir contexto.¿Qué clase utilizarías en cada caso?
1. La edad llega como un objeto.
2. La edad es -5.
3. Una variable no fue declarada.
4. Un JSON tiene una coma inválida.TypeError, RangeError, ReferenceError y SyntaxError, respectivamente.
throw explica cómo se produce una excepción y cómo cambia el recorrido del programa.