TypeScript Academy · Lección

El problema de lanzar errores

Comprenda por qué las excepciones ocultan los fallos al sistema de tipos.

El problema de lanzar errores 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.

Las excepciones son invisibles

Cuando una función ejecuta throw, su firma no lo indica. El sistema de tipos no puede saber qué funciones pueden fallar, por lo que el compilador no ofrece a quienes las llaman ningún incentivo para gestionar los errores.

Una función que lanza excepciones

Esta función parece devolver siempre un número, pero puede lanzar una excepción. El tipo de retorno number oculta por completo el caso de fallo.

function parsePort(s: string): number {
  const n = Number(s);
  if (Number.isNaN(n)) throw new Error("bad port");
  return n;
}
console.log(parsePort("8080")); // 8080

Quienes llaman olvidan capturar

Nada obliga a quien llama a envolver la llamada en try/catch. El error se compila sin problemas y solo aparece como un bloqueo durante la ejecución.

const port = parsePort("oops");
// No compile error; throws at runtime, possibly crashing the app.

try/catch pierde el tipo

Incluso cuando captura la excepción, el valor capturado tiene el tipo unknown (o any). La forma del error no se conserva, por lo que su gestión se basa en suposiciones.

try {
  parsePort("x");
} catch (e) {
  // e: unknown -> you must narrow it manually
}

Los errores como valores

La alternativa consiste en convertir el fallo en un valor ordinario que devuelve la función, en lugar de una excepción que lanza. Así, el tipo de retorno muestra honestamente ambos resultados.

Esquema de una función que devuelve un valor

En lugar de lanzar una excepción, devuelva un objeto etiquetado que describa el éxito o el fallo. Quien llama debe inspeccionarlo antes de utilizar el valor.

type ParseResult =
  | { ok: true; value: number }
  | { ok: false; error: string };

Ahora el tipo dice la verdad

Una función que devuelve ParseResult indica que puede fallar. Entonces, el compilador exige que quien llama gestione la rama de fallo.

function parsePort(s: string): ParseResult {
  const n = Number(s);
  return Number.isNaN(n)
    ? { ok: false, error: "bad port" }
    : { ok: true, value: n };
}

Gestión obligatoria

Como el valor podría pertenecer a cualquiera de las dos ramas, no puede leer value sin comprobar primero ok. El compilador estrecha el tipo únicamente después de la comprobación.

const r = parsePort("oops");
if (r.ok) console.log(r.value);
else console.log("failed:", r.error);

Las excepciones siguen teniendo su lugar

Los fallos verdaderamente inesperados e irrecuperables (errores de programación, falta de memoria) todavía pueden lanzar excepciones. Los errores como valores son especialmente útiles para los fallos esperados, como los de análisis y validación.

Lo explícito frente a lo implícito

Devolver errores hace que la ruta de fallo sea explícita en el tipo, visible en el sitio de la llamada y difícil de ignorar accidentalmente, a diferencia de un throw oculto.

Hacia Result y Option

Esta estructura etiquetada de éxito o fallo se generaliza en un tipo reutilizable Result, mientras que la distinción entre ausencia y presencia se generaliza en Option; ambos conceptos se explican a continuación.

Comprobación rápida

Comprobación rápida de esta lección.

Resumen

Los errores lanzados son invisibles para los tipos: las firmas ocultan los fallos y quienes llaman olvidan capturarlos. Devolver el fallo como un valor explícito (un objeto etiquetado de éxito o error) hace visible la ruta de fallo en el tipo y evita que se ignore, lo que conduce a los tipos Result y Option.

Preguntas frecuentes

¿La lección «El problema de lanzar errores» es gratis?

Sí — el texto completo de «El problema de lanzar errores» 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 «El problema de lanzar errores»?

Comprenda por qué las excepciones ocultan los fallos al sistema de tipos. 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 «El problema de lanzar errores»?

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

← Volver a TypeScript Academy