Kurs JavaScript i TypeScript · Moduł 12: Programowanie funkcyjne
Wzorce FP: funktory i monady
W tej lekcji4
Ustalenie strefy dinozaura to trzy kroki: znajdź dinozaura, weź jego zoneId, znajdź strefę. Każdy krok może zwrócić undefined, a jedno przeoczone sprawdzenie kończy się w środku nocnej zmiany błędem TypeError: Cannot read properties of undefined. Kod pełen ifów chroni przed tym, ale zasłania to, co naprawdę robimy.
W zaawansowanym laboratorium Parku Jurajskiego nie zawsze mamy pewność, czy próbka DNA istnieje, czy analiza się powiodła, czy dane są kompletne. Zamiast sprawdzać warunki na każdym kroku (if/else), możemy użyć eleganckich wzorców z programowania funkcyjnego - funktorów i monad. To jak inteligentne pojemniki na próbki, które same wiedzą, jak obsłużyć brakujące lub uszkodzone dane.
Funktory - pojemniki z mapowaniem
Funktor to obiekt (pojemnik), który implementuje metodę map. Pozwala stosować transformacje do wartości wewnątrz pojemnika, bez konieczności jej wyciągania. Jeden funktor już znasz: tablica, której map przekształca zawartość i zwraca nową tablicę. Najprostszy własny funktor to pudełko na jedną wartość:
// Najprostszy funktor - Box (pojemnik)
class Box {
constructor(value) {
this.value = value;
}
map(fn) {
return new Box(fn(this.value));
}
toString() {
return 'Box(' + this.value + ')';
}
}map nie zmienia this.value, tylko tworzy nowy Box z wynikiem funkcji - to ta sama zasada niemutowalności, którą znasz z poprzedniej lekcji. Ponieważ każde map zwraca pudełko, wywołania łączą się w łańcuch:
// Użycie - łańcuch transformacji
const result = new Box(8000)
.map((weight) => weight / 1000) // Box(8)
.map((tons) => tons + ' tons') // Box('8 tons')
.map((label) => 'Weight: ' + label); // Box('Weight: 8 tons')
console.log(result.value); // 'Weight: 8 tons'Każdy krok dostaje odpakowaną wartość, a wynik wraca do pudełka. Dopiero na końcu sięgamy po result.value.
Maybe - obsługa brakujących wartości
Monada Maybe rozwiązuje problem wartości null/undefined. Zamiast wszędzie sprawdzać if (x !== null), owijamy wartość w Maybe i pozwalamy monadzie obsługiwać brakujące dane. Statyczna metoda of tworzy pojemnik, isNothing sprawdza, czy jest pusty, map działa jak w Box, ale omija pusty pojemnik, flatMap przyjmuje funkcję zwracającą kolejne Maybe, a getOrElse wyciąga wartość lub zwraca domyślną:
class Maybe {
constructor(value) {
this.value = value;
}
static of(value) {
return new Maybe(value);
}
isNothing() {
return this.value === null || this.value === undefined;
}
map(fn) {
return this.isNothing() ? this : Maybe.of(fn(this.value));
}
flatMap(fn) {
return this.isNothing() ? this : fn(this.value);
}
getOrElse(defaultValue) {
return this.isNothing() ? defaultValue : this.value;
}
}Całe bezpieczeństwo siedzi w jednym warunku: pusty Maybe na każde map odpowiada samym sobą, więc funkcja nigdy nie dostanie undefined. Porównaj teraz wyszukiwanie strefy bez Maybe i z nim:
// Bez Maybe - pełno ifów
function getDinoZoneOld(park, dinoId) {
const dino = park.dinosaurs.find((d) => d.id === dinoId);
if (!dino) return 'Unknown';
const zone = park.zones.find((z) => z.id === dino.zoneId);
if (!zone) return 'Unknown';
return zone.name;
}
// Z Maybe - elegancki łańcuch
function getDinoZone(park, dinoId) {
return Maybe.of(park.dinosaurs.find((d) => d.id === dinoId))
.map((dino) => dino.zoneId)
.flatMap((zoneId) => Maybe.of(park.zones.find((z) => z.id === zoneId)))
.map((zone) => zone.name)
.getOrElse('Unknown');
}Ify zniknęły, a przypadek "nie znaleziono" obsługuje jedno getOrElse na końcu. Przy strefie używamy flatMap, bo funkcja z tego kroku sama zwraca Maybe - zwykłe map dałoby Maybe w Maybe. Porządek jest zawsze ten sam: owiń przez Maybe.of, przekształcaj przez map, kroki zwracające Maybe łącz przez flatMap, a wynik wyciągnij przez getOrElse. Najkrótszy łańcuch to Maybe.of(data).map((d) => d.name).getOrElse('Unknown').
Tę samą parę znasz z tablic. flatMap najpierw mapuje, a potem spłaszcza wynik o jeden poziom:
const zoneIds = ['A', 'B'];
const dinosByZone = { A: ['Rex', 'Blue'], B: ['Brachio'] };
zoneIds.map((id) => dinosByZone[id]); // [['Rex', 'Blue'], ['Brachio']]
zoneIds.flatMap((id) => dinosByZone[id]); // ['Rex', 'Blue', 'Brachio']map zwraca tablicę tablic, a flatMap jedną płaską listę. Maybe.flatMap robi to samo z pudełkami. Do prostego odczytu pól wystarczy wbudowane dino?.zone ?? 'Unknown', a Maybe opłaca się, gdy kroki to całe wyszukiwania.
Either - obsługa błędów
Maybe mówi tylko, że wartości brak, ale nie mówi dlaczego. Either reprezentuje wartość, która może być sukcesem (Right) lub porażką (Left). To funkcyjna alternatywa dla try/catch:
class Left {
constructor(value) { this.value = value; }
map(fn) { return this; } // Ignoruje transformacje
flatMap(fn) { return this; }
getOrElse(defaultValue) { return defaultValue; }
isLeft() { return true; }
isRight() { return false; }
}
class Right {
constructor(value) { this.value = value; }
map(fn) { return new Right(fn(this.value)); }
flatMap(fn) { return fn(this.value); }
getOrElse(defaultValue) { return this.value; }
isLeft() { return false; }
isRight() { return true; }
}Obie klasy mają to samo API, ale Right.map stosuje funkcję, a Left.map ją pomija i niesie błąd dalej. Po pierwszej porażce reszta łańcucha się nie wykonuje. Zobaczmy to przy walidacji próbki:
// Użycie w walidacji próby DNA
function validateSample(sample) {
if (!sample.id) return new Left('Missing sample ID');
if (sample.purity < 0.5) return new Left('Purity too low: ' + sample.purity);
if (!sample.species) return new Left('Unknown species');
return new Right(sample);
}
function processSample(sample) {
return validateSample(sample)
.map((s) => ({ ...s, processed: true }))
.map((s) => ({ ...s, label: s.species + '-' + s.id }));
}
// Sukces
const good = processSample({ id: 'S001', purity: 0.95, species: 'T-Rex' });
good.getOrElse('Error'); // { id: 'S001', purity: 0.95, species: 'T-Rex', processed: true, label: 'T-Rex-S001' }
// Porażka
const bad = processSample({ id: 'S002', purity: 0.3, species: 'Raptor' });
bad.getOrElse('Error'); // 'Error' (błąd: 'Purity too low: 0.3')Próbka S001 przechodzi obie transformacje. Dla S002 oba map są pomijane, ale komunikat nie ginie: leży w bad.value, a bad.isLeft() zwraca true. Either nie łapie jednak wyjątków sam z siebie, więc try/catch zostaw na granicy z kodem, który rzuca, jak JSON.parse.
Jak to wszystko się łączy
W żargonie FP monada to funktor, który ma też flatMap (w bibliotekach często chain) i sposób na włożenie wartości do pojemnika, jak of. Filary tego modułu budują się od podstaw: czyste funkcje, niemutowalność, funkcje wyższego rzędu, kompozycja z curryingiem, a na szczycie funktory i monady. W tej samej kolejności refaktoryzujesz kod imperatywny: znajdujesz efekty uboczne, wydzielasz czyste funkcje, pętle zamieniasz na map, filter i reduce, łączysz kroki przez pipe, a ryzykowne miejsca owijasz w Maybe lub Either. Pipeline danych ma podobne warstwy: parsowanie, walidacja z Maybe lub Either, transformacja przez map, agregacja przez reduce i raport - zbudujesz go w projekcie końcowym. Nie owijaj jednak wszystkiego w pojemniki: opłacają się na granicy z danymi z zewnątrz.
Funktor i monada to po prostu pojemnik na próbkę, który sam wie, co zrobić z brakującą lub uszkodzoną zawartością, dzięki czemu Maybe i Either prowadzą łańcuch transformacji do końca zamiast zasypywać Twój kod dziesiątkami sprawdzeń i bloków try/catch.
Kod do tej lekcji: index.js
// Wzorce FP: funktory i monady
console.log("=== Park Jurajski - Inteligentne Pojemniki DNA ===\n");
// --- PRZYKLAD 1: Funktor Box ---
console.log("--- Funktor Box ---");
class Box {
constructor(value) { this.value = value; }
map(fn) { return new Box(fn(this.value)); }
toString() { return "Box(" + JSON.stringify(this.value) + ")"; }
}
const result = new Box(8000)
.map((w) => w / 1000)
.map((t) => t + " tons")
.map((l) => "Weight: " + l);
console.log(result.toString()); // Box("Weight: 8 tons")
// --- PRZYKLAD 2: Maybe ---
console.log("\n--- Monada Maybe ---");
class Maybe {
constructor(value) { this.value = value; }
static of(v) { return new Maybe(v); }
isNothing() { return this.value === null || this.value === undefined; }
map(fn) { return this.isNothing() ? this : Maybe.of(fn(this.value)); }
flatMap(fn) { return this.isNothing() ? this : fn(this.value); }
getOrElse(def) { return this.isNothing() ? def : this.value; }
toString() { return this.isNothing() ? "Maybe(Nothing)" : "Maybe(" + JSON.stringify(this.value) + ")"; }
}
const park = {
dinosaurs: [
{ id: "D01", name: "Rex", zoneId: "Z01" },
{ id: "D02", name: "Blue", zoneId: "Z02" },
],
zones: [
{ id: "Z01", name: "Zone A" },
{ id: "Z02", name: "Zone B" },
],
};
function getDinoZone(parkData, dinoId) {
return Maybe.of(parkData.dinosaurs.find((d) => d.id === dinoId))
.map((dino) => dino.zoneId)
.flatMap((zoneId) => Maybe.of(parkData.zones.find((z) => z.id === zoneId)))
.map((zone) => zone.name)
.getOrElse("Unknown");
}
console.log("Rex zone:", getDinoZone(park, "D01")); // Zone A
console.log("Blue zone:", getDinoZone(park, "D02")); // Zone B
console.log("Unknown:", getDinoZone(park, "D99")); // Unknown
// --- PRZYKLAD 3: Either ---
console.log("\n--- Monada Either ---");
class Left {
constructor(value) { this.value = value; }
map(fn) { return this; }
flatMap(fn) { return this; }
getOrElse(def) { return def; }
isLeft() { return true; }
isRight() { return false; }
toString() { return "Left(" + this.value + ")"; }
}
class Right {
constructor(value) { this.value = value; }
map(fn) { return new Right(fn(this.value)); }
flatMap(fn) { return fn(this.value); }
getOrElse(def) { return this.value; }
isLeft() { return false; }
isRight() { return true; }
toString() { return "Right(" + JSON.stringify(this.value) + ")"; }
}
function validateSample(sample) {
if (!sample.id) return new Left("Missing sample ID");
if (sample.purity < 0.5) return new Left("Purity too low: " + sample.purity);
if (!sample.species) return new Left("Unknown species");
return new Right(sample);
}
function processSample(sample) {
return validateSample(sample)
.map((s) => ({ ...s, processed: true }))
.map((s) => ({ ...s, label: s.species + "-" + s.id }));
}
const good = processSample({ id: "S01", purity: 0.95, species: "T-Rex" });
console.log("Success:", good.toString());
console.log("Value:", JSON.stringify(good.getOrElse("ERROR")));
const bad1 = processSample({ id: "", purity: 0.95, species: "T-Rex" });
console.log("\nFail 1:", bad1.toString());
const bad2 = processSample({ id: "S02", purity: 0.3, species: "Raptor" });
console.log("Fail 2:", bad2.toString());
// --- PRZYKLAD 4: Lancuch Either ---
console.log("\n--- Lancuch Either ---");
function parseInput(raw) {
try { return new Right(JSON.parse(raw)); }
catch (e) { return new Left("Parse error: " + e.message); }
}
const pipeline = (raw) =>
parseInput(raw)
.flatMap((data) => data.name ? new Right(data) : new Left("Missing name"))
.map((data) => ({ ...data, status: "validated" }));
console.log(pipeline('{"name":"Rex"}').toString());
console.log(pipeline('{"age":5}').toString());
console.log(pipeline('invalid json').toString());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. Co musi implementować obiekt, aby był funktorem?
2. Co zwraca Array.flatMap() w porównaniu do Array.map()?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w pionie
Ułóż kroki bezpiecznego pobierania danych z użyciem Maybe:
- Układanie w poziomie
Ułóż elementy wywołania flatMap na Maybe:
- Układanie w poziomie
Ułóż elementy łańcucha Maybe do bezpiecznego wyciągania danych:
- Klikanie w kolejności
Ułóż elementy walidacji z Either:
- Układanie w pionie
Ułóż filary programowania funkcyjnego od najbardziej podstawowego:
- Edytor kodu
Zaimplementuj bezpieczne wyszukiwanie i walidację danych z użyciem Maybe i Either.
- Układanie w pionie
Ułóż elementy implementacji memoize z domknięciem:
- Klikanie w kolejności
Ułóż elementy grupowania tablicy z reduce:
- Układanie w pionie
Ułóż etapy budowania funkcyjnego pipeline przetwarzania danych:
- Układanie w poziomie
Ułóż elementy implementacji partial application:
- Klikanie w kolejności
Ułóż elementy pipeline filter-map-reduce:
- Układanie w pionie
Ułóż etapy refaktoringu z kodu imperatywnego na funkcyjny:
- Układanie w pionie
Ułóż warstwy funkcyjnego pipeline przetwarzania danych od wejścia do wyjścia:
Zadania po tej lekcji
- PytanieFunktor
- Ułóż w kolejnościPrzetwarzanie z Maybe
- Ułóż w kolejnościSkładnia flatMap na Maybe
- Ułóż w kolejnościSkładnia łańcucha Maybe
- Kliknij w kolejnościWalidacja z Either
- PytanieArray.flatMap() vs Array.map()
- Ułóż w kolejnościZasady programowania funkcyjnego
- Zadanie z kodemMaybe i Either w praktyce
- Ułóż w kolejnościSkładnia memoize z closure
- Kliknij w kolejnościPipeline z reduce
- Ułóż w kolejnościEtapy budowania pipeline FP
- PytanieObject.freeze() vs const
- Ułóż w kolejnościSkładnia partial application
- Kliknij w kolejnościŁańcuch filter-map-reduce
- Ułóż w kolejnościEtapy refaktoringu na styl funkcyjny
- Ułóż w kolejnościWarstwy funkcyjnego pipeline danych