0Pricing
TypeScript Academy · Lección

Clases y jerarquías de errores tipadas

Cree clases de error personalizadas con tipos discriminados.

Clases y jerarquías de errores tipadas es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 4 lecciones en total.

Bienvenida

Las clases de error personalizadas en TypeScript proporcionan a los errores una jerarquía de tipos para gestionarlos de forma segura y estructurada.

Extender Error

Cree una clase base AppError con un statusCode.
class AppError extends Error {
  constructor(public message: string, public statusCode = 500) {
    super(message);
    this.name = 'AppError';
  }
}

Jerarquía de errores

Cree subclases tipadas para tipos de error específicos.
class NotFoundError extends AppError {
  constructor(resource: string) { super(`${resource} not found`, 404); }
}
class ValidationError extends AppError {
  constructor(public fields: string[]) { super('Validation failed', 400); }
}

Uso de instanceof

Use instanceof para refinar los tipos de error en bloques catch.
try { doSomething(); }
catch (err) {
  if (err instanceof NotFoundError) res.status(404).json({ error: err.message });
  else if (err instanceof ValidationError) res.status(400).json({ fields: err.fields });
}

Unión discriminada de errores

Use una unión discriminada para gestionar errores con tipos.
type AppError =
  | { kind: 'not_found'; resource: string }
  | { kind: 'unauthorized' }
  | { kind: 'validation'; fields: string[] };

Funciones de fábrica de errores

Cree funciones de fábrica para cada tipo de error.
const errors = {
  notFound: (r: string) => new NotFoundError(r),
  unauthorized: () => new AppError('Unauthorized', 401),
};

Serialización de errores

Serialice los errores para las respuestas de la API.
function serializeError(err: AppError): Record<string, unknown> {
  return { error: err.message, code: err.statusCode, name: err.name };
}

Establecer this.name

Establezca siempre this.name en el nombre de la clase de error para identificar correctamente el error en los registros.
class MyError extends Error {
  readonly name = 'MyError' as const;
  constructor(msg: string) { super(msg); }
}

Errores en Express

Use errores personalizados tipados en los controladores de errores de Express.
app.use((err: unknown, req: Request, res: Response, next: NextFunction) => {
  if (err instanceof AppError) {
    res.status(err.statusCode).json({ error: err.message });
  } else {
    res.status(500).json({ error: 'Internal error' });
  }
});

Patrón de registro de errores

Registre los errores con su tipo y mensaje para facilitar la observabilidad.
function logError(err: unknown): void {
  if (err instanceof Error) console.error(`[${err.name}] ${err.message}`);
  else console.error('Unknown error:', err);
}

Probar tipos de error

Compruebe que las funciones lancen los tipos de error correctos.
test('throws NotFoundError for missing user', async () => {
  await expect(getUser(999)).rejects.toThrow(NotFoundError);
});

Comprobación rápida

¿Qué palabra clave de TypeScript comprueba en tiempo de ejecución si un objeto es una instancia de una clase?

Resumen

Clases y jerarquías de errores tipadas: ha aprendido los conceptos clave de este tema y cómo aplicarlos en proyectos reales de TypeScript.

Preguntas frecuentes

¿La lección «Clases y jerarquías de errores tipadas» es gratis?

Sí — el texto completo de «Clases y jerarquías de errores tipadas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Clases y jerarquías de errores tipadas»?

Cree clases de error personalizadas con tipos discriminados. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar TypeScript Academy?

No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Clases y jerarquías de errores tipadas»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?

Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Clases y jerarquías de errores tipadas
  2. El patrón Result: Ok y Err
  3. Reducción de errores capturados (unknown frente a Error)
  4. Gestión de errores en código TypeScript asíncrono
← Volver a TypeScript Academy