Kurs JavaScript i TypeScript · Moduł 12: Programowanie funkcyjne
Kompozycja funkcji: compose i pipe
W tej lekcji5
Nazwa gatunku przychodzi z sensora jako ' rex ' i zanim trafi do rejestru, musi przejść przez trzy obróbki. Zapis addPrefix(capitalize(normalize(name))) czyta się od środka na zewnątrz, a przy pięciu etapach nawiasy zaczynają przypominać splątaną nić DNA. Chcemy pisać etapy w tej kolejności, w jakiej naprawdę się wykonują.
W laboratorium genetycznym Parku Jurajskiego DNA dinozaura przechodzi przez serię etapów przetwarzania - ekstrakcja, oczyszczanie, sekwencjonowanie, walidacja. Każdy etap to oddzielna operacja, a ich połączenie w łańcuch daje kompletny proces. Dokładnie tak działa kompozycja funkcji - łączenie prostych funkcji w bardziej złożone operacje.
Czym jest kompozycja funkcji?
Kompozycja funkcji polega na łączeniu dwóch lub więcej funkcji, gdzie wynik jednej staje się wejściem następnej. Matematycznie: f(g(x)) - najpierw stosujemy g, potem f.
Oto trzy stanowiska do obróbki nazwy: trim usuwa spacje z brzegów, charAt(0).toUpperCase() powiększa pierwszą literę, a slice(1) dokleja resztę tekstu:
// Pojedyncze operacje na danych dinozaura
const normalize = (name) => name.trim().toLowerCase();
const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
const addPrefix = (name) => 'DINO-' + name;Każda funkcja jest czysta i robi jedną rzecz. Teraz połączmy je na dwa sposoby, najpierw zagnieżdżając wywołania, potem zamykając je w nazwanej funkcji:
// Bez kompozycji - zagnieżdżone wywołania (trudne do czytania)
const result = addPrefix(capitalize(normalize(' rex ')));
// 'DINO-Rex'
// Z kompozycją - czytelny pipeline
const formatDinoName = (name) => addPrefix(capitalize(normalize(name)));
formatDinoName(' rex '); // 'DINO-Rex'Oba zapisy dają 'DINO-Rex'. Druga wersja nadaje procesowi nazwę i można jej używać wielokrotnie, ale kolejność etapów nadal czytasz od prawej do lewej. Funkcje compose i pipe automatyzują takie łączenie dla dowolnej liczby etapów.
Funkcja compose
compose łączy funkcje od prawej do lewej - ostatnia funkcja w liście jest wykonywana pierwsza. To odwzorowanie matematycznej notacji f(g(x)).
Parametr resztowy ...fns zbiera wszystkie przekazane funkcje w tablicę. reduceRight działa jak reduce, ale przechodzi tablicę od końca, a wartością początkową akumulatora są dane wejściowe:
function compose(...fns) {
return (value) => fns.reduceRight(
(acc, fn) => fn(acc),
value
);
}Sama funkcja compose niczego jeszcze nie przetwarza, tylko zwraca nową funkcję czekającą na dane. Sprawdźmy ją na trzech etapach obróbki próbki:
// Funkcje przetwarzające próbę DNA
const extractDNA = (sample) => ({ ...sample, dna: sample.tissue + '-DNA' });
const sequenceDNA = (sample) => ({ ...sample, sequence: sample.dna + '-SEQ' });
const validateDNA = (sample) => ({ ...sample, valid: sample.sequence.length > 5 });
// Compose: od prawej do lewej (extractDNA -> sequenceDNA -> validateDNA)
const processSample = compose(validateDNA, sequenceDNA, extractDNA);
const result = processSample({ tissue: 'TREX-001' });
// { tissue: 'TREX-001', dna: 'TREX-001-DNA', sequence: 'TREX-001-DNA-SEQ', valid: true }extractDNA wykonuje się pierwsza, bo stoi najbardziej na prawo. Każdy etap zwraca nowy obiekt przez spread, więc próbka wejściowa { tissue: 'TREX-001' } zostaje nietknięta, a wynik zbiera pola dopisane po drodze.
Funkcja pipe
pipe to odwrotność compose - łączy funkcje od lewej do prawej. Czyta się jak naturalny przepływ danych, co wielu programistów uważa za bardziej intuicyjne.
Implementacja różni się jednym słowem, reduce zamiast reduceRight, a pierwsza funkcja na liście wykonuje się pierwsza:
function pipe(...fns) {
return (value) => fns.reduce(
(acc, fn) => fn(acc),
value
);
}
// Pipe: od lewej do prawej (naturalny kierunek czytania)
const processSample = pipe(extractDNA, sequenceDNA, validateDNA);
// Identyczny wynik, ale bardziej czytelna kolejnośćTe same trzy etapy dają ten sam wynik co w compose, ale kolejność argumentów odpowiada teraz kolejności wykonania. Etapami mogą być też funkcje zapisane w miejscu, jak w tym raporcie aktywnych dinozaurów:
// Praktyczny przykład - przetwarzanie danych parku
const processReport = pipe(
(data) => data.filter((d) => d.status === 'active'),
(data) => data.map((d) => ({ name: d.name, zone: d.zone })),
(data) => data.sort((a, b) => a.name.localeCompare(b.name)),
);
const parkData = [
{ name: 'Rex', zone: 'A', status: 'active' },
{ name: 'Stego', zone: 'B', status: 'inactive' },
{ name: 'Blue', zone: 'A', status: 'active' },
];
processReport(parkData);
// [{ name: 'Blue', zone: 'A' }, { name: 'Rex', zone: 'A' }]Stego odpada na filtrze, map zostawia nazwę i strefę, a sort z localeCompare układa wynik alfabetycznie. Uwaga na pułapkę: sort zmienia tablicę, na której go wywołasz. Tu jest to bezpieczne, bo sortujemy świeżą tablicę z map, a parkData pozostaje w oryginalnej kolejności. Gdyby sortowanie było pierwszym etapem, użyj toSorted (ES2023), które zwraca posortowaną kopię.
Compose vs Pipe - kiedy którego używać?
Obie funkcje robią to samo, ale w odwrotnej kolejności. Wybór zależy od preferencji, co najlepiej widać na schemacie z trzema etapami:
// compose: od prawej do lewej (jak w matematyce)
const process1 = compose(validate, transform, parse);
// Czytaj: validate(transform(parse(x)))
// pipe: od lewej do prawej (jak naturalny przepływ)
const process2 = pipe(parse, transform, validate);
// Czytaj: x -> parse -> transform -> validateW praktyce pipe jest częściej używany, bo odwzorowuje naturalny kierunek przetwarzania danych - od wejścia do wyjścia, od góry do dołu.
Jak budować pipeline
Sprawdzony porządek pracy wygląda tak: najpierw zdefiniuj czystą funkcję dla każdego kroku, potem przetestuj każdą osobno, następnie połącz je przez pipe lub compose, a na końcu przekaż pipeline'owi dane wejściowe. Pilnuj jednej zasady: każdy etap przyjmuje jeden argument i zwraca to, czego oczekuje następny. Jeśli któryś zapomni o return, kolejny dostanie undefined.
Gdy chcesz podejrzeć dane między etapami, wstaw pomocniczą funkcję tap. Wykonuje ona efekt uboczny, ale oddaje dalej dokładnie tę samą wartość:
// Podgląd danych między etapami, bez zmiany wyniku
const tap = (fn) => (value) => {
fn(value);
return value;
};
const debugReport = pipe(
(data) => data.filter((d) => d.status === 'active'),
tap((data) => console.log('Po filtrze:', data.length)),
(data) => data.map((d) => d.name),
);
debugReport(parkData); // ['Rex', 'Blue'], w konsoli: Po filtrze: 2Konsola pokazuje liczbę aktywnych dinozaurów, a wynik końcowy to wciąż zwykła lista ich nazw - tap niczego w nim nie zmienił. Polecam Ci trzymać tap pod ręką przy debugowaniu i usuwać go przed wdrożeniem. W następnej lekcji zobaczysz, jak currying zamienia funkcje wieloargumentowe w jednoargumentowe, które idealnie pasują do pipe.
Pamiętaj: pipe to taśma w laboratorium - próbka wjeżdża z lewej, przechodzi przez kolejne stanowiska i wyjeżdża z prawej jako gotowy wynik.
Kod do tej lekcji: index.js
// Kompozycja funkcji: compose i pipe
console.log("=== Park Jurajski - Rekombinacja DNA ===\n");
// Implementacja compose (prawo -> lewo)
function compose(...fns) {
return (value) => fns.reduceRight((acc, fn) => fn(acc), value);
}
// Implementacja pipe (lewo -> prawo)
function pipe(...fns) {
return (value) => fns.reduce((acc, fn) => fn(acc), value);
}
// --- PRZYKLAD 1: Formatowanie nazw ---
console.log("--- Compose: Formatowanie nazw ---");
const normalize = (str) => str.trim().toLowerCase();
const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
const addPrefix = (str) => "DINO-" + str;
const formatName = compose(addPrefix, capitalize, normalize);
console.log(formatName(" rex ")); // DINO-Rex
console.log(formatName(" VELOCIRAPTOR ")); // DINO-Velociraptor
// --- PRZYKLAD 2: Pipeline przetwarzania DNA ---
console.log("\n--- Pipe: Przetwarzanie proby DNA ---");
const extractDNA = (sample) => ({ ...sample, dna: sample.tissue + "-DNA" });
const sequenceDNA = (sample) => ({ ...sample, sequence: sample.dna + "-SEQ" });
const assessQuality = (sample) => ({
...sample,
quality: sample.sequence.length > 15 ? "HIGH" : "LOW",
});
const createReport = (sample) => ({
...sample,
report: sample.quality + " quality sample from " + sample.tissue,
});
const processSample = pipe(extractDNA, sequenceDNA, assessQuality, createReport);
const result = processSample({ tissue: "TREX-001" });
console.log("Wynik:", JSON.stringify(result, null, 2));
// --- PRZYKLAD 3: Przetwarzanie danych parku ---
console.log("\n--- Pipe: Raport bezpieczenstwa ---");
const parkData = [
{ name: "Rex", zone: "A", status: "active", danger: 9 },
{ name: "Brachio", zone: "B", status: "active", danger: 2 },
{ name: "Raptor", zone: "A", status: "escaped", danger: 8 },
{ name: "Stego", zone: "B", status: "active", danger: 3 },
{ name: "Blue", zone: "A", status: "active", danger: 7 },
];
const generateReport = pipe(
(data) => data.filter((d) => d.status === "active"),
(data) => data.filter((d) => d.danger >= 5),
(data) => data.map((d) => ({ name: d.name, zone: d.zone, level: d.danger > 7 ? "CRITICAL" : "HIGH" })),
(data) => [...data].sort((a, b) => a.name.localeCompare(b.name)),
);
const report = generateReport(parkData);
console.log("Aktywne zagrozenia:");
report.forEach((r) => console.log(` [${r.level}] ${r.name} - Zone ${r.zone}`));
// --- PRZYKLAD 4: Compose vs Pipe ---
console.log("\n--- Porownanie compose vs pipe ---");
const double = (x) => x * 2;
const addTen = (x) => x + 10;
const square = (x) => x * x;
const withCompose = compose(square, addTen, double);
const withPipe = pipe(double, addTen, square);
console.log("compose(square, addTen, double)(3):", withCompose(3));
console.log("pipe(double, addTen, square)(3):", withPipe(3));
console.log("Oba: 3 -> double(6) -> addTen(16) -> square(256)");Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. W jakiej kolejności pipe wykonuje funkcje?
2. Jaka jest różnica między compose a pipe?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Napisz funkcje normalizujące i klasyfikujące dane, a następnie połącz je za pomocą pipe.
- Układanie w poziomie
Ułóż elementy implementacji funkcji pipe:
- Edytor kodu
Grupuj dane po strefach, oblicz statystyki per typ sensora i zlicz alerty.