TypeScript Academy · Lekcja

Programowanie zorientowane na tory

Łącz operacje, które mogą zakończyć się niepowodzeniem, bez try/catch

Programowanie zorientowane na tory to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej TypeScript Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Metafora torów

Programowanie zorientowane na tory przedstawia obliczenia jako dwa równoległe tory: tor sukcesu i tor błędu. Po przejściu na tor błędu pozostaje się na nim i pomija resztę kroków.

Łączenie funkcji Result

Każdy krok przyjmuje wartość i zwraca Result. Należy połączyć kroki tak, aby pierwszy błąd automatycznie przerwał łańcuch i został przekazany do jego końca.

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: przekształcanie wartości sukcesu

map stosuje zwykłą funkcję do wartości, gdy Result oznacza powodzenie, a błędy przekazuje bez zmian. Pozostaje na torze sukcesu.

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: łączenie kroków mogących zakończyć się błędem

Gdy kolejny krok sam zwraca Result, należy użyć flatMap (nazywanego także andThen). Pozwala to uniknąć zagnieżdżania wartości Result i automatycznie przerywa łańcuch w przypadku błędu.

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;
}

Dlaczego flatMap, a nie map

Użycie map z funkcją zwracającą Result dałoby Result<Result<U,E>,E>. flatMap spłaszcza jeden poziom zagnieżdżenia, zachowując pojedynczy Result.

Przerwanie po pierwszym błędzie

Gdy tylko krok zwróci err, każde kolejne flatMap przekazuje go dalej bez zmian. Pozostałe kroki nigdy się nie wykonują — dokładnie tak jak po przejściu na tor błędu.

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

Budowanie potoku

Należy połączyć kroki walidacji, z których każdy zwraca Result. Pierwszy błąd staje się wynikiem potoku; jeśli wszystkie kroki zakończą się powodzeniem, wartość sukcesu dociera do końca.

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");
}

Uruchamianie potoku

Łączenie za pomocą flatMap przekazuje wartość przez każdy krok mogący zakończyć się błędem. Błąd w dowolnym miejscu zatrzymuje łańcuch i udostępnia ten błąd wywołującemu.

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" }

Łączenie map i flatMap

Należy używać flatMap w krokach, które mogą zakończyć się błędem, a map do czystych przekształceń. Razem pozwalają zachować liniową ścieżkę powodzenia i automatyczną obsługę błędów.

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

Bez try/catch

Cały potok wyraża powodzenie i błąd za pomocą wartości. Nie ma tu try/catch, a typ każdego kroku sprawia, że ścieżka błędu jest jawna i nie można jej pominąć.

Dlaczego to rozwiązanie się skaluje

Programowanie zorientowane na tory sprawia, że złożone przepływy pracy pozostają czytelne: każdy krok jest mały i czysty, błędy są automatycznie przekazywane dalej, a dodanie kroku nie komplikuje istniejącej obsługi błędów.

Szybki test

Szybki test z tego tematu.

Podsumowanie

Programowanie zorientowane na tory łączy kroki zwracające Result za pomocą map (przekształcanie sukcesu) oraz flatMap/andThen (łączenie kroków mogących zakończyć się błędem i spłaszczanie zagnieżdżonych wartości Result). Pierwszy err przerywa resztę, przekazując błąd do końca bez użycia try/catch.

Często zadawane pytania

Czy lekcja „Programowanie zorientowane na tory” jest bezpłatna?

Tak — pełny tekst „Programowanie zorientowane na tory” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu TypeScript Academy, przejdź na CoddyKit PRO. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Programowanie zorientowane na tory”?

Łącz operacje, które mogą zakończyć się niepowodzeniem, bez try/catch Ćwiczysz TypeScript Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć TypeScript Academy?

Nie wymagamy żadnego doświadczenia. TypeScript Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Programowanie zorientowane na tory”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji TypeScript Academy?

Tak. Każda lekcja TypeScript Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do TypeScript Academy