TypeScript Academy · Lección

Tipos Option y Maybe

Modele explícitamente la presencia o ausencia de un valor.

Tipos Option y Maybe es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 3 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.

Modelar la ausencia

A veces un valor puede simplemente estar ausente, sin que haya ningún error que informar. Option (también llamado Maybe) representa explícitamente la presencia o ausencia, como alternativa a null y undefined.

Definir Option

Option es una unión discriminada con una etiqueta some. Cuando some es true, existe un valor; cuando es false, no hay nada.

type Option<T> =
  | { some: true; value: T }
  | { some: false };

Constructores

Las funciones auxiliares some y none facilitan la creación de valores Option, de forma similar a ok/err de Result.

const some = <T>(value: T): Option<T> => ({ some: true, value });
const none: Option<never> = { some: false };

Devolver un Option

Una búsqueda que podría no encontrar nada devuelve un Option en lugar de T | undefined. La opcionalidad queda expresada explícitamente en el tipo.

function find<T>(arr: T[], pred: (x: T) => boolean): Option<T> {
  const hit = arr.find(pred);
  return hit === undefined ? none : some(hit);
}

Estrechamiento con some

Compruebe opt.some para acceder al valor de forma segura. El compilador solo permite leer value dentro de la rama en la que está presente.

const r = find([1, 2, 3], n => n > 1);
if (r.some) console.log(r.value); // 2
else console.log("not found");

¿Por qué no usar simplemente null?

null y undefined son fáciles de olvidar y se mezclan con otros tipos. Un Option explícito obliga a gestionar el caso de ausencia y deja claro que es intencionado.

Option frente a T | undefined

Ambos pueden representar la ausencia, pero Option es una estructura deliberada y con nombre a la que puede añadir funciones auxiliares (map, getOrElse), lo que fomenta una gestión coherente en todo el código.

// undefined is implicit and easy to ignore;
// Option is explicit and self-documenting.

Una función auxiliar getOrElse

Para convertir un Option en un valor concreto, proporcione una alternativa para el caso de ausencia. Así, la gestión de la ausencia queda concentrada en un único lugar evidente.

function getOrElse<T>(o: Option<T>, fallback: T): T {
  return o.some ? o.value : fallback;
}
console.log(getOrElse(none, 0)); // 0

Aplicar un map sobre un Option

Un map transforma el valor interno únicamente cuando está presente y deja la ausencia intacta. Esto permite encadenar transformaciones sin repetir comprobaciones.

function mapOpt<T, U>(o: Option<T>, f: (t: T) => U): Option<U> {
  return o.some ? some(f(o.value)) : none;
}
console.log(mapOpt(some(5), n => n * 2)); // { some: true, value: 10 }

Option frente a Result

Utilice Option cuando la ausencia no tenga un motivo asociado (por ejemplo, una búsqueda sin resultados). Utilice Result cuando el fallo incluya un error explicativo. Elija según necesite comunicar o no por qué ocurrió.

Componer Options

Como Option dispone de map y getOrElse, las cadenas de pasos opcionales siguen siendo legibles, y la ausencia interrumpe automáticamente la cadena.

const out = getOrElse(mapOpt(find([1,2], n => n > 1), n => n + 100), -1);
console.log(out); // 102

Comprobación rápida

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

Resumen

Option<T> es { some: true; value } o { some: false }, y representa explícitamente la ausencia en lugar de usar null. Constrúyalo con some/none, estreche el tipo mediante some y utilice funciones auxiliares como getOrElse y map. Prefiera Option cuando la ausencia no necesite un motivo y Result cuando el fallo sí lo necesite.

Preguntas frecuentes

¿La lección «Tipos Option y Maybe» es gratis?

Sí — el texto completo de «Tipos Option y Maybe» 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 «Tipos Option y Maybe»?

Modele explícitamente la presencia o ausencia de un valor. 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 3 de 4.

¿Cuánto tiempo toma la lección «Tipos Option y Maybe»?

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