TypeScript Academy · Lekcja

Kompozycja funkcji z typami

Komponuj funkcje, zachowując bezpieczeństwo typów

Kompozycja funkcji z typami to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 3 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.

Czym jest kompozycja

Kompozycja funkcji łączy małe funkcje w większą. compose(f, g) tworzy funkcję, która najpierw stosuje g, a następnie przekazuje wynik do f.

Podstawowa definicja

Matematycznie compose(f, g)(x) = f(g(x)). Funkcje są wykonywane od prawej do lewej: funkcja znajdująca się najbardziej po prawej stronie jest wykonywana jako pierwsza.

const compose = (f: (n: number) => number, g: (n: number) => number) =>
  (x: number) => f(g(x));
const inc = (n: number) => n + 1;
const dbl = (n: number) => n * 2;
console.log(compose(inc, dbl)(5)); // 11 (5*2 then +1)

Kolejność od prawej do lewej

Kolejność ma znaczenie. compose(inc, dbl) najpierw podwaja, a następnie zwiększa wartość, natomiast compose(dbl, inc) najpierw ją zwiększa. Kompozycję należy czytać od środka na zewnątrz.

console.log(compose(dbl, inc)(5)); // 12 (5+1 then *2)

Typowanie kompozycji za pomocą generyków

Generyki pozwalają, aby typy wejściowy i wyjściowy były różne. g mapuje A na B, f mapuje B na C, a wynik mapuje A na C.

function compose<A, B, C>(f: (b: B) => C, g: (a: A) => B): (a: A) => C {
  return a => f(g(a));
}

Zmiana typów po drodze

Łańcuch generyków A -> B -> C pozwala kompozycji przekształcać wartość między różnymi postaciami, na przykład z ciągu znaków w liczbę, a następnie z powrotem w ciąg znaków.

const length = (s: string) => s.length;
const toStr = (n: number) => "len=" + n;
const describe = compose(toStr, length);
console.log(describe("hello")); // len=5

Granica typów musi pasować

Typ wyjściowy g musi odpowiadać typowi wejściowemu f. Jeśli typy się nie zgadzają, kompilator odrzuca kompozycję, wcześnie wykrywając błędy w połączeniach.

// compose(length, toStr) would error:
// toStr returns string, length expects string -> ok here,
// but mismatched pairs are flagged by the compiler.

Kompozycja trzech funkcji

Można zagnieżdżać kompozycję albo napisać wersję przyjmującą trzy argumenty. Zasada wykonywania od prawej do lewej nadal obowiązuje we wszystkich tych przypadkach.

const compose3 = <A, B, C, D>(
  f: (c: C) => D, g: (b: B) => C, h: (a: A) => B
) => (a: A): D => f(g(h(a)));
const inc = (n: number) => n + 1;
const dbl = (n: number) => n * 2;
const neg = (n: number) => -n;
console.log(compose3(neg, dbl, inc)(3)); // -8

Kompozycja tworzy potoki

Łącząc małe, czyste funkcje, można deklaratywnie składać złożone transformacje. Każdy element pozostaje możliwy do przetestowania niezależnie.

const trim = (s: string) => s.trim();
const upper = (s: string) => s.toUpperCase();
const clean = compose(upper, trim);
console.log(clean("  hi ")); // HI

Dlaczego czyste funkcje najlepiej poddają się kompozycji

Kompozycja zakłada, że każda funkcja zależy wyłącznie od swoich danych wejściowych. Czyste funkcje gwarantują ten warunek, dlatego ich kompozycja tworzy kolejną przewidywalną, czystą funkcję.

compose vs pipe

compose działa od prawej do lewej i odzwierciedla zapis matematyczny. Wiele osób preferuje czytanie od lewej do prawej — właśnie to zapewnia pipe, omówione w następnej części.

Małe elementy

Kompozycja sprawdza się najlepiej, gdy każda funkcja wykonuje jedną małą czynność. Niewielkie, nazwane i czyste kroki sprawiają, że złożony potok sam wyjaśnia swoje działanie i łatwo go przeorganizować.

Szybkie sprawdzenie

Szybkie sprawdzenie tej lekcji.

Podsumowanie

compose(f, g)(x) = f(g(x)) działa od prawej do lewej. Generyczne typowanie tworzy łańcuch A -> B -> C, dlatego typ wyjściowy g musi odpowiadać typowi wejściowemu f, co pozwala kompilatorowi zweryfikować potok małych, czystych funkcji.

Często zadawane pytania

Czy lekcja „Kompozycja funkcji z typami” jest bezpłatna?

Tak — pełny tekst „Kompozycja funkcji z typami” 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 „Kompozycja funkcji z typami”?

Komponuj funkcje, zachowując bezpieczeństwo typów Ć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 3 z 4.

Ile czasu zajmuje lekcja „Kompozycja funkcji z typami”?

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