Railway-oriented programming
Kedja operationer som kan misslyckas utan try/catch.
Railway-oriented programming är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för TypeScript Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i TypeScript Academy innehåller totalt 4 lektioner.
Järnvägsmetaforen
Järnvägsorienterad programmering beskriver en beräkning som två parallella spår: ett framgångsspår och ett felspår. När du väl har bytt till felspåret stannar du där och hoppar över resten.
Kedja Result-funktioner
Varje steg tar emot ett värde och returnerar ett Result. Målet är att koppla ihop stegen så att det första misslyckandet avbryter kedjan och följer med till slutet.
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: Omvandla framgångsvärdet
map tillämpar en vanlig funktion på värdet när Result är ok och skickar misslyckanden vidare utan ändringar. Det håller sig på framgångsspåret.
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: Kedja steg som kan misslyckas
När nästa steg självt returnerar ett Result använder du flatMap (även kallat andThen). Det undviker nästlade Result och avbryter kedjan vid misslyckande.
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;
}Varför flatMap och inte map
Om du använde map med en funktion som returnerar ett Result skulle du få Result<Result<U,E>,E>. flatMap plattar ut ett lager och behåller ett enda Result.
Avbryt vid första felet
Så snart ett steg returnerar err skickar varje senare flatMap det vidare utan ändringar. De återstående stegen körs aldrig, precis som när du byter till felspåret.
const start = err("boom") as Result<number, string>;
const out = flatMap(start, n => ok(n + 1));
console.log(out); // { ok: false, error: "boom" }Bygg en pipeline
Kombinera valideringssteg där varje steg returnerar ett Result. Det första misslyckandet blir pipelinens resultat. Om alla steg lyckas flödar framgångsvärdet till slutet.
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");
}Kör pipelinen
Genom att kedja flatMap skickas värdet genom varje steg som kan misslyckas. Ett misslyckande var som helst stoppar kedjan och visar det felet.
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" }Kombinera map och flatMap
Använd flatMap för steg som kan misslyckas och map för rena omvandlingar. Tillsammans håller de det lyckade flödet linjärt och felen automatiska.
const result = map(flatMap(parseNum("10"), positive), n => n * 2);
console.log(result); // { ok: true, value: 20 }try/catch behövs inte
Hela pipelinen uttrycker framgång och misslyckande genom värden. Ingen try/catch behövs, och typen för varje steg gör felvägen explicit och omöjlig att undvika.
Därför skalar det
Järnvägsorienterad kod håller komplexa arbetsflöden lättlästa: varje steg är litet och rent, fel sprids automatiskt och ett nytt steg komplicerar inte den befintliga felhanteringen.
Snabb kontroll
Snabb kontroll av lektionen.
Sammanfattning
Järnvägsorienterad programmering kedjar steg som returnerar Result med map (omvandlar framgång) och flatMap/andThen (kedjar steg som kan misslyckas och plattar ut nästlade Result). Det första err avbryter resten och sprids till slutet utan try/catch.
Lär dig TypeScript med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 101
- Lektioner
- 352
Vanliga frågor
Är lektionen ”Railway-oriented programming” gratis?
Ja – hela texten till ”Railway-oriented programming” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i TypeScript Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i TypeScript Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Railway-oriented programming”?
Kedja operationer som kan misslyckas utan try/catch. Ni övar på TypeScript Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig TypeScript Academy?
Du behöver inga förkunskaper. Utbildningen i TypeScript Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.
Hur lång tid tar lektionen ”Railway-oriented programming”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här TypeScript Academy-lektionen?
Ja. Varje TypeScript Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Problemet med att kasta fel
- Modellera Result-typer
- Option- och Maybe-typer
- Railway-oriented programming