Railway-Oriented Programming
Verketten Sie möglicherweise fehlschlagende Operationen ohne try/catch.
Railway-Oriented Programming ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.
Die Railway-Metapher
Railway-orientierte Programmierung stellt eine Berechnung als zwei parallele Gleise dar: ein Erfolgs- und ein Fehlergleis. Sobald Sie auf das Fehlergleis wechseln, bleiben Sie dort und überspringen den Rest.
Result-Funktionen verketten
Jeder Schritt nimmt einen Wert entgegen und gibt ein Result zurück. Wir möchten die Schritte so verbinden, dass der erste Fehler die Kette vorzeitig beendet und bis zum Ende weitergereicht wird.
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: Erfolgswert transformieren
map wendet eine gewöhnliche Funktion auf den Wert an, wenn das Result erfolgreich ist, und gibt Fehler unverändert weiter. Es bleibt auf dem Erfolgsgleis.
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: Fehleranfällige Schritte verketten
Wenn der nächste Schritt selbst ein Result zurückgibt, verwenden Sie flatMap (auch andThen genannt). So vermeiden Sie verschachtelte Results und beenden die Kette bei einem Fehler vorzeitig.
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;
}Warum flatMap statt map
Wenn Sie map mit einer Funktion verwenden würden, die ein Result zurückgibt, erhielten Sie Result<Result<U,E>,E>. flatMap glättet diese Verschachtelung um eine Ebene und behält ein einzelnes Result bei.
Beim ersten Fehler vorzeitig abbrechen
Sobald ein Schritt err zurückgibt, reichen alle späteren flatMap-Aufrufe den Fehler unverändert weiter. Die verbleibenden Schritte werden nie ausgeführt – genau wie beim Wechsel auf das Fehlergleis.
const start = err("boom") as Result<number, string>;
const out = flatMap(start, n => ok(n + 1));
console.log(out); // { ok: false, error: "boom" }Eine Pipeline erstellen
Verketten Sie Validierungsschritte, von denen jeder ein Result zurückgibt. Der erste Fehler wird zum Ergebnis der Pipeline. Wenn alle Schritte erfolgreich sind, fließt der Erfolgswert bis zum Ende.
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");
}Die Pipeline ausführen
Durch das Verketten von flatMap wird der Wert durch jeden fehleranfälligen Schritt weitergereicht. Ein Fehler an beliebiger Stelle stoppt die Kette und gibt diesen Fehler zurück.
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" }map und flatMap kombinieren
Verwenden Sie flatMap für Schritte, die fehlschlagen können, und map für reine Transformationen. Zusammen halten sie den Erfolgsweg linear und behandeln Fehler automatisch.
const result = map(flatMap(parseNum("10"), positive), n => n * 2);
console.log(result); // { ok: true, value: 20 }Kein try/catch erforderlich
Die gesamte Pipeline drückt Erfolg und Fehler über Werte aus. Es gibt kein try/catch, und der Typ jedes Schritts macht den Fehlerpfad explizit und unvermeidbar.
Warum das Verfahren skalierbar ist
Railway-orientierter Code hält komplexe Abläufe lesbar: Jeder Schritt ist klein und rein, Fehler werden automatisch weitergereicht, und das Hinzufügen eines Schritts macht die bestehende Fehlerbehandlung nicht komplizierter.
Kurzer Check
Kurzer Check zu dieser Lektion.
Rückblick
Railway-orientierte Programmierung verkettet Schritte, die Result zurückgeben, mit map (Erfolg transformieren) und flatMap/andThen (fehleranfällige Schritte verketten und verschachtelte Results glätten). Das erste err beendet den Rest der Kette vorzeitig und wird ohne try/catch bis zum Ende weitergereicht.
Häufig gestellte Fragen
Ist die Lektion „Railway-Oriented Programming“ kostenlos?
Ja — der vollständige Text von „Railway-Oriented Programming“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des TypeScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Railway-Oriented Programming“?
Verketten Sie möglicherweise fehlschlagende Operationen ohne try/catch. Du übst TypeScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um TypeScript Academy zu starten?
Keine Vorkenntnisse erforderlich. TypeScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Railway-Oriented Programming“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser TypeScript Academy-Lektion Code schreiben und ausführen?
Ja. Jede TypeScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Das Problem mit dem Auslösen von Fehlern
- Result-Typen modellieren
- Option- und Maybe-Typen
- Railway-Oriented Programming