Railway-oriented programming
Kjed sammen operasjoner som kan mislykkes, uten try/catch.
Railway-oriented programming er en gratis leksjon i TypeScript Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i TypeScript Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i TypeScript Academy inneholder totalt 4 leksjoner.
Metaforen med jernbanespor
Railway-oriented programming fremstiller en beregning som to parallelle spor: et suksesspor og et feilspor. Når beregningen først går over på feilsporet, blir den der og hopper over resten.
Lenke Result-funksjoner
Hvert trinn tar imot en verdi og returnerer en Result. Målet er å koble trinnene slik at den første feilen avbryter kjeden og følger den helt til slutten.
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: Transformer suksessverdien
map bruker en vanlig funksjon på verdien når Result er vellykket, og sender feil videre uten endringer. Beregningen forblir på suksessporet.
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: Lenke trinn som kan mislykkes
Når det neste trinnet selv returnerer en Result, brukes flatMap (også kalt andThen). Det unngår nøstede Result-verdier og avbryter kjeden ved feil.
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;
}Hvorfor flatMap, ikke map
Hvis map ble brukt med en funksjon som returnerer en Result, ville resultatet blitt Result<Result<U,E>,E>. flatMap flater ut dette ett nivå og beholder én enkelt Result.
Avbryte ved første feil
Så snart et trinn returnerer err, sender alle senere flatMap-kall feilen videre uten endringer. De gjenstående trinnene kjøres aldri, akkurat som når beregningen går over på feilsporet.
const start = err("boom") as Result<number, string>;
const out = flatMap(start, n => ok(n + 1));
console.log(out); // { ok: false, error: "boom" }Bygge en pipeline
Sett sammen valideringstrinn der hvert trinn returnerer en Result. Den første feilen blir pipeline-resultatet. Hvis alle trinn lykkes, flyter suksessverdien helt til slutten.
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");
}Kjøre pipelinen
Ved å lenke flatMap føres verdien gjennom hvert trinn som kan mislykkes. En feil hvor som helst stopper kjeden og gjør feilen synlig.
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" }Kombinere map og flatMap
Bruk flatMap for trinn som kan mislykkes, og map for rene transformasjoner. Sammen holder de den vanlige suksessbanen lineær og feilhåndteringen automatisk.
const result = map(flatMap(parseNum("10"), positive), n => n * 2);
console.log(result); // { ok: true, value: 20 }Ingen try/catch nødvendig
Hele pipelinen uttrykker suksess og feil gjennom verdier. Det finnes ingen try/catch, og typen til hvert trinn gjør feilbanen eksplisitt og umulig å unngå.
Hvorfor det skalerer
Railway-orientert kode holder komplekse arbeidsflyter lesbare: hvert trinn er lite og rent, feil videreføres automatisk, og det å legge til et trinn gjør ikke den eksisterende feilhåndteringen mer komplisert.
Hurtigsjekk
Hurtigsjekk av denne leksjonen.
Oppsummering
Railway-oriented programming lenker trinn som returnerer Result, ved hjelp av map (transformerer suksessverdien) og flatMap/andThen (lenker trinn som kan mislykkes og flater ut nøstede Result-verdier). Den første err avbryter resten og videreføres helt til slutten uten try/catch.
Lær deg TypeScript med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 101
- Leksjoner
- 352
Ofte stilte spørsmål
Er leksjonen «Railway-oriented programming» gratis?
Ja – hele teksten i «Railway-oriented programming» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av TypeScript Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i TypeScript Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Railway-oriented programming»?
Kjed sammen operasjoner som kan mislykkes, uten try/catch. Du øver på TypeScript Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med TypeScript Academy?
Ingen tidligere erfaring er nødvendig. TypeScript Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.
Hvor lang tid tar leksjonen «Railway-oriented programming»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne TypeScript Academy-leksjonen?
Ja. Alle TypeScript Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Problemet med å kaste feil
- Modellere Result-typer
- Option- og Maybe-typer
- Railway-oriented programming