Kurs JavaScript i TypeScript · Moduł 12: Programowanie funkcyjne
Currying i częściowa aplikacja
W tej lekcji5
Wyobraź sobie system karmienia dinozaurów w parku. Każdy gatunek ma swoje wymagania - rodzaj pożywienia, porcję i porę karmienia. Zamiast za każdym razem podawać wszystkie parametry, możemy przygotować funkcje "wstępnie skonfigurowane" dla danego gatunku. To właśnie robi currying - przekształca funkcję wieloargumentową w sekwencję funkcji jednoargumentowych.
Jest też drugi, bardziej techniczny problem. pipe z poprzedniej lekcji przekazuje każdemu etapowi dokładnie jedną wartość, więc funkcja wymagająca gatunku, pokarmu i porcji po prostu do niego nie pasuje. Potrzebujemy sposobu, żeby część argumentów ustawić wcześniej, a na końcu zostawić funkcję jednoargumentową.
Czym jest currying?
Currying to technika przekształcania funkcji przyjmującej wiele argumentów w sekwencję funkcji, z których każda przyjmuje dokładnie jeden argument.
Zacznijmy od zwykłej funkcji z trzema parametrami i jej wersji curried zapisanej klasycznie, przez zagnieżdżone function:
// Zwykła funkcja z 3 argumentami
function feedDinosaur(species, food, portion) {
return species + ' dostaje ' + portion + 'kg ' + food;
}
feedDinosaur('T-Rex', 'meat', 50);
// Wersja curried - sekwencja funkcji jednoargumentowych
function feedDinosaurCurried(species) {
return function(food) {
return function(portion) {
return species + ' dostaje ' + portion + 'kg ' + food;
};
};
}
feedDinosaurCurried('T-Rex')('meat')(50);Oba wywołania zwracają 'T-Rex dostaje 50kg meat'. Wywołanie feedDinosaurCurried('T-Rex') nikogo jeszcze nie karmi, tylko zwraca funkcję czekającą na pokarm, a dopiero trzecia para nawiasów uruchamia właściwą logikę. Wewnętrzne funkcje pamiętają species i food dzięki domknięciom, którym przyjrzymy się w następnej lekcji.
Funkcje strzałkowe pozwalają zapisać to samo znacznie krócej, bo każda strzałka to kolejny etap:
// To samo ze strzałkami (bardziej zwięźle)
const feedCurried = (species) => (food) => (portion) =>
species + ' dostaje ' + portion + 'kg ' + food;Czytaj to od lewej: funkcja od gatunku zwraca funkcję od pokarmu, a ta zwraca funkcję od porcji. Zmienił się tylko zapis, zachowanie jest identyczne jak w wersji z function.
Praktyczne zastosowanie curryingu
Prawdziwa siła curryingu tkwi w tworzeniu wyspecjalizowanych funkcji. Tym razem ostatni etap zwraca obiekt karmienia ze znacznikiem czasu:
const feedCurried = (species) => (food) => (portion) =>
({ species, food, portion, timestamp: Date.now() });
// Specjalizowane funkcje dla gatunków
const feedRex = feedCurried('T-Rex');
const feedRexMeat = feedRex('meat');
// Użycie wyspecjalizowanych funkcji
feedRexMeat(50); // { species: 'T-Rex', food: 'meat', portion: 50, ... }
feedRexMeat(30); // { species: 'T-Rex', food: 'meat', portion: 30, ... }
// Można też dla innego gatunku
const feedBrachio = feedCurried('Brachiosaurus');
const feedBrachioPlants = feedBrachio('plants');
feedBrachioPlants(200); // { species: 'Brachiosaurus', food: 'plants', portion: 200, ... }feedRex i feedRexMeat to zwykłe funkcje, które możesz przechowywać, przekazywać i wywoływać wiele razy, a feedCurried pozostaje ogólna i bez przeszkód obsłuży Brachiozaura. Zapis { species, food, portion } to skrót od { species: species, ... }. Uwaga techniczna: Date.now() sprawia, że ostatni etap nie jest czysty, bo dwa wywołania z tą samą porcją dadzą różne znaczniki czasu. Wersja bez czasu, const feed = (species) => (food) => (portion) => ({ species, food, portion }), jest już czysta.
Uniwersalna funkcja curry
Możemy napisać uniwersalną funkcję curry, która automatycznie przekształca dowolną funkcję. Kluczem jest właściwość fn.length, czyli liczba parametrów zadeklarowanych przez funkcję (bez parametru resztowego i bez parametrów od pierwszego z wartością domyślną):
function curry(fn) {
return function curried(...args) {
if (args.length >= fn.length) {
return fn(...args);
}
return (...moreArgs) => curried(...args, ...moreArgs);
};
}curried zbiera argumenty. Gdy jest ich już co najmniej tyle, ile wynosi fn.length, wywołuje oryginał, a w przeciwnym razie zwraca funkcję, która dołoży kolejne. Sprawdźmy to na funkcji budującej wybieg:
// Użycie
function createEnclosure(zone, type, capacity, voltage) {
return { zone, type, capacity, voltage };
}
const curriedCreate = curry(createEnclosure);
// Można wywołać na różne sposoby:
curriedCreate('A')('carnivore')(5)(10000);
curriedCreate('A', 'carnivore')(5, 10000);
curriedCreate('A', 'carnivore', 5)(10000);
curriedCreate('A', 'carnivore', 5, 10000);
// Wszystkie wywołania dają ten sam wynikKażde wywołanie zwraca { zone: 'A', type: 'carnivore', capacity: 5, voltage: 10000 }. Ściśle biorąc, wersja przyjmująca kilka argumentów naraz łączy currying z częściową aplikacją. Tak działają też funkcje curry z bibliotek Ramda i lodash. Pułapka: funkcja zadeklarowana jako (...args) => ... ma length równe 0, więc curry wywoła ją od razu.
Częściowa aplikacja (Partial Application)
Częściowa aplikacja to pokrewna technika - "zamraża" część argumentów funkcji, tworząc nową funkcję z mniejszą liczbą parametrów.
partial przyjmuje funkcję i dowolną liczbę argumentów startowych (presetArgs), a zwraca funkcję czekającą na resztę (laterArgs). Operator spread skleja obie listy w jedno wywołanie:
function partial(fn, ...presetArgs) {
return (...laterArgs) => fn(...presetArgs, ...laterArgs);
}Zastosujmy ją do funkcji dziennika incydentów, z której korzysta cała ochrona parku, i zbudujmy z niej kilka wyspecjalizowanych loggerów:
// Funkcja logowania incydentów
function logIncident(severity, zone, message) {
return '[' + severity + '] Zone ' + zone + ': ' + message;
}
// Wyspecjalizowane loggery
const logCritical = partial(logIncident, 'CRITICAL');
const logWarning = partial(logIncident, 'WARNING');
const logCriticalZoneA = partial(logIncident, 'CRITICAL', 'A');
logCritical('B', 'Fence breach detected');
// '[CRITICAL] Zone B: Fence breach detected'
logCriticalZoneA('T-Rex escaped!');
// '[CRITICAL] Zone A: T-Rex escaped!'W logCritical zamrożony jest jeden argument, a w logCriticalZoneA od razu dwa. Pierwotna logIncident się nie zmieniła i nadal przyjmuje trzy argumenty. Ten sam efekt da wbudowane bind: logIncident.bind(null, 'CRITICAL').
Currying vs częściowa aplikacja
Choć obie techniki tworzą wyspecjalizowane funkcje, różnią się sposobem działania:
- Currying: zawsze tworzy łańcuch funkcji jednoargumentowych
- Częściowa aplikacja: "zamraża" dowolną liczbę argumentów naraz
Specjalizacja przez currying ma zawsze te same etapy: definiujesz ogólną funkcję curried, podajesz pierwszy argument i dostajesz funkcję częściowo zastosowaną, kolejne argumenty dalej ją zawężają, a ostatni zwraca wynik. Moja rada: funkcje do pipeline'ów pisz w kolejności "konfiguracja najpierw, dane na końcu", na przykład filterBy(key)(value)(arr). Po podaniu konfiguracji zostaje funkcja jednoargumentowa gotowa do pipe, a do jednorazowego zamrożenia kilku argumentów istniejącej funkcji wystarczy partial. W projekcie końcowym właśnie tak zbudujesz narzędzia do filtrowania odczytów.
Pamiętaj: currying to stacja karmienia konfigurowana krok po kroku - gatunek, pokarm, porcja - a każde ustawienie daje Ci nową, gotową do pracy maszynę.
Kod do tej lekcji: index.js
// Currying i czesciowa aplikacja
console.log("=== Park Jurajski - Etapowe Przetwarzanie Gatunkow ===\n");
// --- PRZYKLAD 1: Podstawowy currying ---
console.log("--- Currying: System karmienia ---");
const feedDinosaur = (species) => (food) => (portion) =>
`${species} dostaje ${portion}kg ${food}`;
// Specjalizowane funkcje
const feedRex = feedDinosaur("T-Rex");
const feedRexMeat = feedRex("meat");
console.log(feedRexMeat(50)); // T-Rex dostaje 50kg meat
console.log(feedRexMeat(30)); // T-Rex dostaje 30kg meat
const feedBrachio = feedDinosaur("Brachiosaurus");
console.log(feedBrachio("plants")(200)); // Brachiosaurus dostaje 200kg plants
// --- PRZYKLAD 2: Uniwersalna funkcja curry ---
console.log("\n--- Uniwersalny curry ---");
function curry(fn) {
return function curried(...args) {
if (args.length >= fn.length) {
return fn(...args);
}
return (...moreArgs) => curried(...args, ...moreArgs);
};
}
function createEnclosure(zone, type, capacity, voltage) {
return { zone, type, capacity, voltage };
}
const curriedCreate = curry(createEnclosure);
// Rozne sposoby wywolania
const r1 = curriedCreate("A")("carnivore")(5)(10000);
const r2 = curriedCreate("A", "carnivore")(5, 10000);
const r3 = curriedCreate("A", "carnivore", 5, 10000);
console.log("Wywolanie 1:", JSON.stringify(r1));
console.log("Wywolanie 2:", JSON.stringify(r2));
console.log("Identyczne?", JSON.stringify(r1) === JSON.stringify(r2));
// Specjalizowane fabryki
const createCarnivoreZone = curriedCreate("X")("carnivore");
console.log("Zone X-5:", JSON.stringify(createCarnivoreZone(5)(15000)));
console.log("Zone X-10:", JSON.stringify(createCarnivoreZone(10)(20000)));
// --- PRZYKLAD 3: Czesciowa aplikacja ---
console.log("\n--- Czesciowa aplikacja ---");
function partial(fn, ...presetArgs) {
return (...laterArgs) => fn(...presetArgs, ...laterArgs);
}
function logIncident(severity, zone, message) {
return `[${severity}] Zone ${zone}: ${message}`;
}
const logCritical = partial(logIncident, "CRITICAL");
const logWarning = partial(logIncident, "WARNING");
const logCriticalA = partial(logIncident, "CRITICAL", "A");
console.log(logCritical("B", "Fence breach"));
console.log(logWarning("A", "Sensor malfunction"));
console.log(logCriticalA("T-Rex escaped!"));
// --- PRZYKLAD 4: Currying z map/filter ---
console.log("\n--- Currying w praktyce ---");
const filterByField = curry((field, value, arr) =>
arr.filter((item) => item[field] === value)
);
const dinosaurs = [
{ name: "Rex", diet: "carnivore", zone: "A" },
{ name: "Blue", diet: "carnivore", zone: "A" },
{ name: "Brachio", diet: "herbivore", zone: "B" },
{ name: "Stego", diet: "herbivore", zone: "B" },
];
const filterByDiet = filterByField("diet");
const getCarnivores = filterByDiet("carnivore");
const getHerbivores = filterByDiet("herbivore");
console.log("Drapiezniki:", getCarnivores(dinosaurs).map((d) => d.name));
console.log("Roslinozerce:", getHerbivores(dinosaurs).map((d) => d.name));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. Czym jest currying w programowaniu funkcyjnym?
2. Czym różni się częściowa aplikacja (partial application) od curryingu?
Zadania praktyczne w grze
- Edytor kodu
Użyj uniwersalnej funkcji curry do stworzenia wyspecjalizowanych filtrów i loggerów.
- Układanie w pionie
Ułóż etapy tworzenia wyspecjalizowanej funkcji przez currying:
- Klikanie w kolejności
Ułóż elementy curried funkcji strzałkowej:
- Edytor kodu
Użyj partial() do stworzenia wyspecjalizowanych filtrów i połącz je w pipeline z pipe().