Manejo de Errores
## Objetivos de Aprendizaje
- Entender tipos de errores en JavaScript
- Dominar try/catch/finally
- Crear clases de errores personalizadas
- Implementar manejo global de errores
## Tipos de Errores
### SyntaxError
```javascript
// JSON.parse("json inválido"); // SyntaxError
const x = ; // SyntaxError
```
### TypeError
```javascript
const obj = null;
obj.propiedad; // TypeError: Cannot read property of null
const fn = undefined;
fn(); // TypeError: fn is not a function
```
### ReferenceError
```javascript
console.log(variableNoDefinida); // ReferenceError
```
### RangeError
```javascript
const arr = new Array(-1); // RangeError
```
### URIError
```javascript
decodeURIComponent("%2"); // URIError
```
## try/catch/finally
```javascript
try {
const datos = JSON.parse(datosUsuario);
console.log(datos);
} catch (error) {
console.error("JSON inválido:", error.message);
} finally {
console.log("Limpieza aquí");
}
```
## El Objeto Error
```javascript
try {
throw new Error("Algo salió mal");
} catch (error) {
console.log(error.name); // "Error"
console.log(error.message); // "Algo salió mal"
console.log(error.stack); // Stack trace
}
```
## Throwing Errors
```javascript
// Lanzar primitivo (no recomendado)
throw "Error de cadena";
throw 42;
// Lanzar objeto Error (recomendado)
throw new Error("Mensaje de error");
throw new TypeError("Tipo inesperado");
throw new RangeError("Número fuera de rango");
```
## Clases de Errores Personalizadas
```javascript
class ValidationError extends Error {
constructor(message, field) {
super(message);
this.name = "ValidationError";
this.field = field;
}
}
class NotFoundError extends Error {
constructor(recurso) {
super(`${recurso} no encontrado`);
this.name = "NotFoundError";
this.recurso = recurso;
}
}
function encontrarUsuario(id) {
const usuario = baseDeDatos.buscar(id);
if (!usuario) {
throw new NotFoundError("Usuario");
}
return usuario;
}
```
## Manejo Asíncrono
### Con Promesas
```javascript
fetch("/api/datos")
.then(respuesta => {
if (!respuesta.ok) {
throw new Error("Error HTTP");
}
return respuesta.json();
})
.then(datos => console.log(datos))
.catch(error => console.error("Falló:", error));
```
### Con async/await
```javascript
async function obtenerDatos() {
try {
const respuesta = await fetch("/api/datos");
if (!respuesta.ok) {
throw new Error("Error HTTP");
}
const datos = await respuesta.json();
return datos;
} catch (error) {
console.error("Falló:", error);
throw error;
}
}
```
## finally con async
```javascript
async function procesarArchivo(archivo) {
let manejador;
try {
manejador = await fs.open(archivo);
const datos = await manejador.leer();
return datos;
} catch (error) {
console.error("Error:", error);
} finally {
if (manejador) {
await manejador.cerrar();
}
}
}
```
## Manejo Global de Errores
### Navegador
```javascript
window.addEventListener("error", (event) => {
console.error("Error global:", event.error);
});
window.addEventListener("unhandledrejection", (event) => {
console.error("Rechazo no manejado:", event.reason);
});
```
### Node.js
```javascript
process.on("uncaughtException", (error) => {
console.error("Excepción no capturada:", error);
});
process.on("unhandledRejection", (reason, promise) => {
console.error("Rechazo no manejado en:", promise, "razón:", reason);
});
```
## Patrones de Manejo de Errores
### Optional Chaining para Prevenir Errores
```javascript
// En lugar de
if (usuario && usuario.direccion && usuario.direccion.ciudad) {
console.log(usuario.direccion.ciudad);
}
console.log(usuario?.direccion?.ciudad);
```
### Nullish Coalescing para Valores por Defecto
```javascript
const nombre = usuario?.nombre ?? "Anónimo";
```
### Degradación Elegante
```javascript
try {
const resultado = operacionRiesgosa();
mostrarResultado(resultado);
} catch {
mostrarReserva();
}
```
## Resumen
- Usar `try/catch/finally` para manejo síncrono
- Siempre manejar errores asíncronos con `.catch()` o try/catch en async
- Crear clases de errores personalizadas para tipos específicos
- Usar `finally` para código de limpieza que debe ejecutarse
- Configurar manejo global de errores para excepciones no capturadas
- Nunca silenciar errores - al mínimo, registrarlos
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →