TypeScript Academy · Lección

Programación orientada a Railway

Encadene operaciones que pueden fallar sin utilizar try/catch.

Programación orientada a Railway es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 4 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.

La metáfora del ferrocarril

La programación orientada a ferrocarriles representa un cálculo como dos vías paralelas: una vía de éxito y otra de fallo. Una vez que cambia a la vía de fallo, permanece en ella y omite el resto.

Encadenar funciones Result

Cada paso recibe un valor y devuelve un Result. Queremos conectar los pasos de modo que el primer fallo interrumpa la cadena y se propague hasta el final.

type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };
const ok = <T>(value: T): Result<T, never> => ({ ok: true, value });
const err = <E>(error: E): Result<never, E> => ({ ok: false, error });

map: transformar el valor de éxito

map aplica una función normal al valor cuando el Result es correcto y transmite los fallos sin modificarlos. Permanece en la vía de éxito.

function map<T, U, E>(r: Result<T, E>, f: (t: T) => U): Result<U, E> {
  return r.ok ? ok(f(r.value)) : r;
}
console.log(map(ok(2), n => n + 1)); // { ok: true, value: 3 }

flatMap: encadenar pasos susceptibles de fallar

Cuando el siguiente paso devuelve a su vez un Result, utilice flatMap (también llamado andThen). Así evita anidar Results y la cadena se interrumpe en caso de fallo.

function flatMap<T, U, E>(r: Result<T, E>, f: (t: T) => Result<U, E>): Result<U, E> {
  return r.ok ? f(r.value) : r;
}

Por qué flatMap y no map

Si utilizara map con una función que devuelve un Result, obtendría Result<Result<U,E>,E>. flatMap aplana ese nivel, manteniendo un único Result.

Interrumpir en el primer error

En cuanto un paso devuelve err, todos los flatMap posteriores lo transmiten sin modificarlo. Los pasos restantes nunca se ejecutan, exactamente como al cambiar a la vía de fallo.

const start = err("boom") as Result<number, string>;
const out = flatMap(start, n => ok(n + 1));
console.log(out); // { ok: false, error: "boom" }

Construir una canalización

Componga pasos de validación, cada uno de los cuales devuelva un Result. El primer fallo se convierte en el resultado de la canalización; si todos tienen éxito, el valor resultante fluye hasta el final.

function parseNum(s: string): Result<number, string> {
  const n = Number(s);
  return Number.isNaN(n) ? err("not a number") : ok(n);
}
function positive(n: number): Result<number, string> {
  return n > 0 ? ok(n) : err("must be positive");
}

Ejecutar la canalización

Encadenar flatMap hace pasar el valor por cada paso susceptible de fallar. Un fallo en cualquier punto detiene la cadena y muestra ese error.

const good = flatMap(parseNum("5"), positive);
console.log(good); // { ok: true, value: 5 }
const bad = flatMap(parseNum("-3"), positive);
console.log(bad); // { ok: false, error: "must be positive" }

Combinar map y flatMap

Utilice flatMap para los pasos que pueden fallar y map para las transformaciones puras. Juntos mantienen lineal el camino habitual y automatizan los errores.

const result = map(flatMap(parseNum("10"), positive), n => n * 2);
console.log(result); // { ok: true, value: 20 }

No se necesita try/catch

Toda la canalización expresa el éxito y el fallo mediante valores. No hay ningún try/catch, y el tipo de cada paso hace que la ruta de error sea explícita e inevitable.

Por qué es escalable

El código orientado a ferrocarriles mantiene legibles los flujos de trabajo complejos: cada paso es pequeño y puro, los errores se propagan automáticamente y añadir un paso no complica la gestión de errores existente.

Comprobación rápida

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

Resumen

La programación orientada a ferrocarriles encadena pasos que devuelven Result mediante map (transformar el éxito) y flatMap/andThen (encadenar pasos susceptibles de fallar y aplanar Results anidados). El primer err interrumpe el resto y se propaga hasta el final sin try/catch.

Preguntas frecuentes

¿La lección «Programación orientada a Railway» es gratis?

Sí — el texto completo de «Programación orientada a Railway» 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 «Programación orientada a Railway»?

Encadene operaciones que pueden fallar sin utilizar try/catch. 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 4 de 4.

¿Cuánto tiempo toma la lección «Programación orientada a Railway»?

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