Kurs JavaScript i TypeScript · Moduł 9: Wzorce projektowe i architektura
Programowanie funkcyjne w JavaScript/TypeScript
W tej lekcji6
Wyobraź sobie laboratorium, w którym ta sama próbka DNA daje inny wynik zależnie od pory dnia, bo funkcja analizy podgląda globalną zmienną. Programowanie funkcyjne leczy to czystymi funkcjami, niemutowalnością i kompozycją, dzięki którym kod jest przewidywalny, testowalny i łatwiejszy w utrzymaniu.
Czyste funkcje (Pure Functions)
Czysta funkcja spełnia dwa warunki:
- Determinizm - dla tych samych argumentów zawsze zwraca ten sam wynik
- Brak efektów ubocznych - nie modyfikuje zewnętrznego stanu i nie wykonuje operacji I/O
Przykłady nieczystych funkcji
Każda z tych funkcji łamie jeden z warunków. Który?
// Nieczysta funkcja - zależy od zewnętrznego stanu
let tax = 0.23;
function calculatePrice(basePrice) {
return basePrice * (1 + tax); // Zależy od zewnętrznej zmiennej
}
// Nieczysta funkcja - modyfikuje zewnętrzny stan
let counter = 0;
function incrementCounter() {
counter++; // Efekt uboczny - modyfikacja globalnej zmiennej
return counter;
}
// Nieczysta funkcja - efekt uboczny (I/O)
function greetUser(name) {
console.log(`Witaj, ${name}!`); // Efekt uboczny - wypisanie na konsolę
return name;
}
// Nieczysta funkcja - niedeterminizm
function getCurrentTimestamp() {
return Date.now(); // Różne wyniki dla każdego wywołania
}
// Nieczysta funkcja - modyfikuje argument
function addItem(array, item) {
array.push(item); // Mutuje przekazany argument
return array;
}calculatePrice i getCurrentTimestamp łamią determinizm, a pozostałe mają efekty uboczne: zmieniają zmienną globalną, piszą do konsoli albo mutują przekazaną tablicę.
Przykłady czystych funkcji
Czyste odpowiedniki dostają wszystko w argumentach i zwracają nowe wartości:
// Czysta funkcja - determinizm i brak efektów ubocznych
function calculatePrice(basePrice: number, taxRate: number): number {
return basePrice * (1 + taxRate);
}
// Czysta funkcja - operacja matematyczna
function add(a: number, b: number): number {
return a + b;
}
// Czysta funkcja - transformacja danych
function formatFullName(firstName: string, lastName: string): string {
return `${firstName} ${lastName}`;
}
// Czysta funkcja - praca z tablicami (bez mutacji)
function addItem<T>(array: T[], item: T): T[] {
return [...array, item]; // Zwraca nową tablicę
}
// Czysta funkcja - filtrowanie
function filterEvenNumbers(numbers: number[]): number[] {
return numbers.filter(num => num % 2 === 0);
}
// Czysta funkcja - przekształcenie obiektu
interface User {
id: number;
name: string;
age: number;
}
function updateUserAge(user: User, newAge: number): User {
return {
...user, // Spread operator - kopiowanie istniejących właściwości
age: newAge // Nadpisanie wieku
};
}
// Czysta funkcja - walidacja
function isValidEmail(email: string): boolean {
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
return emailRegex.test(email);
}
// Użycie czystych funkcji
const products = [
{ name: 'Laptop', basePrice: 2000 },
{ name: 'Mouse', basePrice: 50 },
{ name: 'Keyboard', basePrice: 150 }
];
const TAX_RATE = 0.23;
const productsWithTax = products.map(product => ({
...product,
finalPrice: calculatePrice(product.basePrice, TAX_RATE)
}));
console.log(productsWithTax);Podatek jest parametrem, a addItem i updateUserAge zwracają kopie, więc oryginały zostają nietknięte.
Zalety czystych funkcji
Determinizm daje dwie supermoce: test bez przygotowywania świata i memoizację, czyli zapamiętywanie wyników:
// Łatwość testowania - brak zależności zewnętrznych
function calculateDiscount(price: number, discountPercent: number): number {
return price * (discountPercent / 100);
}
// Test jednostkowy jest prosty i niezawodny
console.assert(calculateDiscount(100, 10) === 10);
console.assert(calculateDiscount(200, 25) === 50);
// Memoizacja - optymalizacja dzięki determinizmowi
function memoize<TArgs extends any[], TReturn>(
fn: (...args: TArgs) => TReturn
): (...args: TArgs) => TReturn {
const cache = new Map<string, TReturn>();
return (...args: TArgs): TReturn => {
const key = JSON.stringify(args);
if (cache.has(key)) {
console.log('Cache hit!');
return cache.get(key)!;
}
console.log('Computing...');
const result = fn(...args);
cache.set(key, result);
return result;
};
}
// Funkcja kosztowna obliczeniowo
function fibonacci(n: number): number {
if (n <= 1) return n;
return fibonacci(n - 1) + fibonacci(n - 2);
}
// Wersja z memoizacją
const memoizedFibonacci = memoize(fibonacci);
console.log(memoizedFibonacci(10)); // Computing... 55
console.log(memoizedFibonacci(10)); // Cache hit! 55memoize to funkcja wyższego rzędu (higher-order function): przyjmuje inną funkcję jako argument lub zwraca funkcję, a tu robi jedno i drugie. Takie są też map, filter czy subscribe ze wzorca Observer. Wywołania rekurencyjne w fibonacci omijają jednak pamięć, więc zysk widać dopiero przy powtórnym wywołaniu.
Niemutowalność (Immutability)
Niemutowalność oznacza, że obiekty i struktury danych nie są modyfikowane po utworzeniu. Zamiast tego tworzone są nowe wersje z wprowadzonymi zmianami, jak w archiwum, gdzie nie nadpisujesz starej próbki, tylko dokładasz nową.
Praca z prymitywami
Z prymitywami masz to za darmo, bo napisy i liczby w JavaScript są z natury niemutowalne:
// Prymitywy w JavaScript są z natury niemutowalne
let name = 'Jan';
let newName = name.toUpperCase(); // Tworzy nowy string
console.log(name); // 'Jan' - oryginał niezmieniony
console.log(newName); // 'JAN' - nowa wartośćtoUpperCase() nie zmienia napisu name, tylko zwraca nowy.
Praca z tablicami
Z tablicami uważaj, bo część metod mutuje oryginał. Porównaj obie grupy:
// Mutowalne operacje (modyfikują oryginalną tablicę)
const originalArray = [1, 2, 3];
originalArray.push(4); // Mutuje
originalArray.pop(); // Mutuje
originalArray.splice(1, 1); // Mutuje
originalArray.sort(); // Mutuje
// Niemutowalne operacje (tworzą nowe tablice)
const numbers = [1, 2, 3];
// Dodawanie elementów
const withNewElement = [...numbers, 4];
const withElementAtStart = [0, ...numbers];
const withElementInMiddle = [...numbers.slice(0, 2), 2.5, ...numbers.slice(2)];
// Usuwanie elementów
const withoutFirst = numbers.slice(1);
const withoutLast = numbers.slice(0, -1);
const withoutMiddle = numbers.filter((_, index) => index !== 1);
// Modyfikacja elementów
const doubled = numbers.map(x => x * 2);
const incremented = numbers.map(x => x + 1);
// Sortowanie
const sorted = [...numbers].sort();
const reverseSorted = [...numbers].sort((a, b) => b - a);
console.log('Oryginalna tablica:', numbers); // [1, 2, 3]
console.log('Podwojone:', doubled); // [2, 4, 6]
console.log('Posortowane:', sorted); // [1, 2, 3]
// Zaawansowane operacje niemutowalne
function updateArrayElement<T>(
array: T[],
index: number,
newValue: T
): T[] {
return array.map((item, i) => i === index ? newValue : item);
}
function moveArrayElement<T>(
array: T[],
fromIndex: number,
toIndex: number
): T[] {
const result = [...array];
const [removed] = result.splice(fromIndex, 1);
result.splice(toIndex, 0, removed);
return result;
}
const fruits = ['apple', 'banana', 'cherry'];
const updatedFruits = updateArrayElement(fruits, 1, 'blueberry');
const movedFruits = moveArrayElement(fruits, 0, 2);
console.log('Oryginalne:', fruits); // ['apple', 'banana', 'cherry']
console.log('Zaktualizowane:', updatedFruits); // ['apple', 'blueberry', 'cherry']
console.log('Przesunięte:', movedFruits); // ['banana', 'cherry', 'apple']Reguła: push, pop, splice i sort zmieniają tablicę, a spread, slice, map i filter zwracają nową. Uwaga: sort() bez funkcji porównującej sortuje jak napisy ([10, 9, 1].sort() da [1, 10, 9]), a od ES2023 masz niemutujące toSorted(), toReversed(), toSpliced() i with().
Praca z obiektami
Obiekty kopiujemy operatorem spread. Przy zagnieżdżeniu kopiujemy każdy poziom, który zmieniamy:
// Mutowalne operacje na obiektach
const user = { id: 1, name: 'Jan', age: 30 };
user.age = 31; // Mutuje
user.email = 'jan@example.com'; // Mutuje
delete user.name; // Mutuje
// Niemutowalne operacje na obiektach
const originalUser = { id: 1, name: 'Jan', age: 30 };
// Aktualizacja właściwości
const olderUser = { ...originalUser, age: 31 };
// Dodawanie właściwości
const userWithEmail = { ...originalUser, email: 'jan@example.com' };
// Usuwanie właściwości
const { name, ...userWithoutName } = originalUser;
// Zagnieżdżone aktualizacje
interface Address {
street: string;
city: string;
country: string;
}
interface UserWithAddress {
id: number;
name: string;
address: Address;
}
const userWithAddress: UserWithAddress = {
id: 1,
name: 'Jan',
address: {
street: 'Main St',
city: 'Warsaw',
country: 'Poland'
}
};
// Mutowalna aktualizacja zagnieżdżona
userWithAddress.address.city = 'Krakow'; // Mutuje
// Niemutowalna aktualizacja zagnieżdżona
const userInKrakow = {
...userWithAddress,
address: {
...userWithAddress.address,
city: 'Krakow'
}
};
// Funkcje pomocnicze do niemutowalnych operacji
function updateProperty<T, K extends keyof T>(
obj: T,
key: K,
value: T[K]
): T {
return { ...obj, [key]: value };
}
function updateNestedProperty<T>(
obj: T,
path: string[],
value: any
): T {
if (path.length === 1) {
return { ...obj, [path[0]]: value };
}
const [firstKey, ...restPath] = path;
return {
...obj,
[firstKey]: updateNestedProperty(obj[firstKey as keyof T], restPath, value)
};
}
// Użycie funkcji pomocniczych
const updatedUser = updateProperty(originalUser, 'age', 35);
const userInGdansk = updateNestedProperty(
userWithAddress,
['address', 'city'],
'Gdansk'
);
console.log('Oryginał:', originalUser); // { id: 1, name: 'Jan', age: 30 }
console.log('Zaktualizowany:', updatedUser); // { id: 1, name: 'Jan', age: 35 }Spread robi płytką kopię, dlatego address rozpakowujemy osobno. W TypeScripcie (strict) linie z user.email i delete user.name się nie skompilują, bo typ nie ma pola email, a delete wymaga pola opcjonalnego.
Biblioteki do niemutowalności
Ręczne kopiowanie głębokich struktur męczy, dlatego powstał Immer: piszesz kod wyglądający jak mutacja szkicu (draft), a biblioteka zwraca nowy stan:
// Immer - biblioteka ułatwiająca pracę z niemutowalnymi strukturami
// npm install immer
import { produce } from 'immer';
interface Todo {
id: number;
text: string;
completed: boolean;
}
const todos: Todo[] = [
{ id: 1, text: 'Nauka JavaScript', completed: false },
{ id: 2, text: 'Nauka TypeScript', completed: true },
{ id: 3, text: 'Nauka React', completed: false }
];
// Z Immer - wygląda jak mutacja, ale tworzy nowy stan
const updatedTodos = produce(todos, draft => {
const todo = draft.find(t => t.id === 1);
if (todo) {
todo.completed = true;
}
});
const todosWithNewItem = produce(todos, draft => {
draft.push({
id: 4,
text: 'Nauka programowania funkcyjnego',
completed: false
});
});
console.log('Oryginalne todos:', todos);
console.log('Zaktualizowane todos:', updatedTodos);
console.log('Todos z nowym elementem:', todosWithNewItem);
// Zaawansowany przykład z zagnieżdżonymi strukturami
interface Project {
id: number;
name: string;
todos: Todo[];
members: string[];
}
const project: Project = {
id: 1,
name: 'Projekt A',
todos: todos,
members: ['Jan', 'Anna']
};
const updatedProject = produce(project, draft => {
// Dodanie nowego członka
draft.members.push('Piotr');
// Oznaczenie wszystkich todos jako zakończone
draft.todos.forEach(todo => {
todo.completed = true;
});
// Zmiana nazwy projektu
draft.name = 'Projekt A - Zakończony';
});
console.log('Oryginalny projekt:', project);
console.log('Zaktualizowany projekt:', updatedProject);Oryginały pozostają nietknięte, a niezmienione fragmenty są współdzielone. Przy głęboko zagnieżdżonym stanie polecam Immer.
Currying (rozwijanie funkcji)
Currying to technika przekształcania funkcji przyjmującej wiele argumentów w serię funkcji, z których każda przyjmuje jeden argument.
Podstawowy currying
Zobacz tę samą funkcję mnożenia w wersji klasycznej i rozwiniętej:
// Funkcja z wieloma argumentami
function multiply(a: number, b: number, c: number): number {
return a * b * c;
}
console.log(multiply(2, 3, 4)); // 24
// Wersja curry
function curriedMultiply(a: number) {
return function(b: number) {
return function(c: number) {
return a * b * c;
};
};
}
console.log(curriedMultiply(2)(3)(4)); // 24
// Wersja curry z funkcjami strzałkowymi
const curriedMultiplyArrow = (a: number) => (b: number) => (c: number) => a * b * c;
console.log(curriedMultiplyArrow(2)(3)(4)); // 24
// Częściowe aplikowanie (partial application)
const multiplyBy2 = curriedMultiply(2);
const multiplyBy2And3 = multiplyBy2(3);
console.log(multiplyBy2And3(4)); // 24
console.log(multiplyBy2And3(5)); // 30Każde wywołanie zwraca kolejną funkcję, aż padnie ostatni argument. multiplyBy2 to częściowe zastosowanie (partial application): pierwszy argument pamięta dzięki domknięciu.
Praktyczne zastosowania curryingu
Prawdziwa moc pojawia się, gdy pierwsze argumenty to konfiguracja, a ostatni to dane:
// System logowania z curryingiem
type LogLevel = 'info' | 'warn' | 'error';
const logger = (level: LogLevel) => (message: string) => (context?: object) => {
const timestamp = new Date().toISOString();
const logEntry = {
level,
message,
timestamp,
context
};
console.log(JSON.stringify(logEntry, null, 2));
};
// Tworzenie specjalizowanych loggerów
const infoLogger = logger('info');
const errorLogger = logger('error');
const warnLogger = logger('warn');
// Użycie
infoLogger('Aplikacja została uruchomiona')();
errorLogger('Błąd połączenia z bazą danych')({ database: 'PostgreSQL' });
warnLogger('Wysokie zużycie pamięci RAM')({ usage: '85%' });
// System walidacji z curryingiem
type Validator<T> = (value: T) => boolean;
const createValidator = <T>(predicate: (value: T) => boolean) =>
(errorMessage: string) =>
(value: T): { isValid: boolean; error?: string } => {
const isValid = predicate(value);
return isValid ? { isValid } : { isValid, error: errorMessage };
};
// Predykaty walidacji
const isNotEmpty = (value: string) => value.trim().length > 0;
const isEmail = (value: string) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
const isMinLength = (minLength: number) => (value: string) => value.length >= minLength;
const isNumber = (value: string) => !isNaN(Number(value));
// Tworzenie walidatorów
const requiredValidator = createValidator(isNotEmpty)('Pole jest wymagane');
const emailValidator = createValidator(isEmail)('Nieprawidłowy format email');
const passwordValidator = createValidator(isMinLength(8))('Hasło musi mieć co najmniej 8 znaków');
const ageValidator = createValidator(isNumber)('Wiek musi być liczbą');
// Użycie walidatorów
console.log(requiredValidator('Jan')); // { isValid: true }
console.log(requiredValidator('')); // { isValid: false, error: 'Pole jest wymagane' }
console.log(emailValidator('jan@example.com')); // { isValid: true }
console.log(passwordValidator('123')); // { isValid: false, error: 'Hasło musi mieć co najmniej 8 znaków' }
// System konfiguracji API z curryingiem
const apiCall = (baseUrl: string) =>
(endpoint: string) =>
(method: 'GET' | 'POST' | 'PUT' | 'DELETE') =>
(data?: any) => {
const config = {
url: `${baseUrl}${endpoint}`,
method,
data
};
console.log('API Call:', config);
// Tutaj byłoby rzeczywiste wywołanie API
return Promise.resolve({ success: true, config });
};
// Konfiguracja dla różnych środowisk
const devApi = apiCall('https://dev-api.example.com');
const prodApi = apiCall('https://api.example.com');
// Specjalizowane funkcje dla różnych endpointów
const usersApi = devApi('/users');
const productsApi = devApi('/products');
// Konkretne operacje
const getUsers = usersApi('GET');
const createUser = usersApi('POST');
const updateUser = usersApi('PUT');
// Użycie
getUsers();
createUser({ name: 'Jan', email: 'jan@example.com' });
updateUser({ id: 1, name: 'Jan Kowalski' });Każda z tych funkcji to mała fabryka: createValidator produkuje walidatory, a apiCall klientów API. Wzorzec Factory robił to klasą, na przykład DinoFactory z metodą create(type) zwracającą new Dinosaur(type), oddzielając tworzenie od użycia.
Automatyczny currying
Helper curry rozwija funkcję automatycznie, zbierając argumenty, aż będzie ich tyle, ile ma parametrów:
// Funkcja pomocnicza do automatycznego curryingu
function curry<TArgs extends any[], TReturn>(
fn: (...args: TArgs) => TReturn
): (...args: any[]) => any {
return function curried(...args: any[]) {
if (args.length >= fn.length) {
return fn(...args as TArgs);
} else {
return function(...nextArgs: any[]) {
return curried(...args, ...nextArgs);
};
}
};
}
// Przykład użycia automatycznego curryingu
function sum(a: number, b: number, c: number, d: number): number {
return a + b + c + d;
}
const curriedSum = curry(sum);
// Różne sposoby wywołania
console.log(curriedSum(1, 2, 3, 4)); // 10
console.log(curriedSum(1)(2)(3)(4)); // 10
console.log(curriedSum(1, 2)(3, 4)); // 10
console.log(curriedSum(1)(2, 3)(4)); // 10
// Częściowe aplikowanie
const add5 = curriedSum(5);
const add5And10 = add5(10);
const add5And10And15 = add5And10(15);
console.log(add5And10And15(20)); // 50
// Przykład z filtrowaniem i sortowaniem
function filterAndSort<T>(
predicate: (item: T) => boolean,
compareKey: keyof T,
array: T[]
): T[] {
return array
.filter(predicate)
.sort((a, b) => {
if (a[compareKey] < b[compareKey]) return -1;
if (a[compareKey] > b[compareKey]) return 1;
return 0;
});
}
const curriedFilterAndSort = curry(filterAndSort);
interface Product {
id: number;
name: string;
price: number;
category: string;
inStock: boolean;
}
const products: Product[] = [
{ id: 1, name: 'Laptop', price: 2000, category: 'Electronics', inStock: true },
{ id: 2, name: 'Mouse', price: 50, category: 'Electronics', inStock: false },
{ id: 3, name: 'Book', price: 25, category: 'Books', inStock: true },
{ id: 4, name: 'Keyboard', price: 150, category: 'Electronics', inStock: true }
];
// Specjalizowane funkcje
const filterInStockSortByPrice = curriedFilterAndSort(
(product: Product) => product.inStock
)('price');
const filterElectronicsSortByName = curriedFilterAndSort(
(product: Product) => product.category === 'Electronics'
)('name');
console.log('Dostępne produkty posortowane po cenie:', filterInStockSortByPrice(products));
console.log('Elektronika posortowana po nazwie:', filterElectronicsSortByName(products));curry opiera się na fn.length, która nie liczy parametru rest ani parametrów od pierwszego z wartością domyślną.
Kompozycja funkcji (Function Composition)
Kompozycja funkcji to łączenie prostych funkcji w bardziej złożone przez przekazywanie wyniku jednej jako argumentu kolejnej, jak etapy linii laboratoryjnej.
Podstawowa kompozycja
Zamiast zagnieżdżać wywołania, budujemy potok. compose wykonuje funkcje od prawej do lewej, a pipe od lewej do prawej:
// Proste funkcje
const add = (x: number) => x + 1;
const multiply = (x: number) => x * 2;
const square = (x: number) => x * x;
// Bez kompozycji - zagnieżdżone wywołania
const result1 = square(multiply(add(5))); // ((5 + 1) * 2)^2 = 144
// Funkcja compose - wykonuje funkcje od prawej do lewej
function compose<T>(...functions: Array<(arg: T) => T>) {
return (value: T): T => {
return functions.reduceRight((acc, fn) => fn(acc), value);
};
}
// Funkcja pipe - wykonuje funkcje od lewej do prawej (bardziej intuicyjna)
function pipe<T>(...functions: Array<(arg: T) => T>) {
return (value: T): T => {
return functions.reduce((acc, fn) => fn(acc), value);
};
}
// Użycie compose
const composedFunction = compose(square, multiply, add);
console.log(composedFunction(5)); // 144
// Użycie pipe (bardziej czytelne)
const pipedFunction = pipe(add, multiply, square);
console.log(pipedFunction(5)); // 144
// Praktyczny przykład - przetwarzanie danych użytkownika
interface User {
firstName: string;
lastName: string;
age: number;
email: string;
}
const users: User[] = [
{ firstName: 'Jan', lastName: 'Kowalski', age: 25, email: 'jan@example.com' },
{ firstName: 'Anna', lastName: 'Nowak', age: 30, email: 'anna@example.com' },
{ firstName: 'Piotr', lastName: 'Wiśniewski', age: 22, email: 'piotr@example.com' }
];
// Funkcje pomocnicze
const filterAdults = (users: User[]) => users.filter(user => user.age >= 18);
const sortByAge = (users: User[]) => [...users].sort((a, b) => a.age - b.age);
const mapToFullNames = (users: User[]) =>
users.map(user => `${user.firstName} ${user.lastName}`);
// Kompozycja
const processUsers = pipe(
filterAdults,
sortByAge,
mapToFullNames
);
const processedUsers = processUsers(users);
console.log(processedUsers); // ['Piotr Wiśniewski', 'Jan Kowalski', 'Anna Nowak']Oba warianty dają 144, ale pipe czyta się w kolejności wykonania i to jego polecam. Haczyk: każdy krok musi zwracać ten sam typ, więc przy mapToFullNames TypeScript zgłosi błąd, nawet bez trybu strict.
Zaawansowana kompozycja z TypeScript
Gdy typ zmienia się po drodze, każdy etap potrzebuje własnego parametru typu, jak w compose3:
// Typowana kompozycja dla różnych typów
function compose2<A, B, C>(f: (b: B) => C, g: (a: A) => B) {
return (a: A): C => f(g(a));
}
function compose3<A, B, C, D>(
f: (c: C) => D,
g: (b: B) => C,
h: (a: A) => B
) {
return (a: A): D => f(g(h(a)));
}
// Przykład użycia typowanej kompozycji
const parseNumber = (str: string): number => parseFloat(str);
const addTax = (price: number): number => price * 1.23;
const formatCurrency = (amount: number): string => `${amount.toFixed(2)} PLN`;
const processPrice = compose3(formatCurrency, addTax, parseNumber);
console.log(processPrice('100')); // '123.00 PLN'
// System walidacji z kompozycją
type ValidationResult = {
isValid: boolean;
errors: string[];
};
type Validator<T> = (value: T) => ValidationResult;
const combineValidators = <T>(...validators: Validator<T>[]): Validator<T> => {
return (value: T): ValidationResult => {
const results = validators.map(validator => validator(value));
return {
isValid: results.every(result => result.isValid),
errors: results.flatMap(result => result.errors)
};
};
};
// Pojedyncze walidatory
const isRequired: Validator<string> = (value: string) => ({
isValid: value.trim().length > 0,
errors: value.trim().length === 0 ? ['Pole jest wymagane'] : []
});
const isEmail: Validator<string> = (value: string) => {
const isValid = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
return {
isValid,
errors: isValid ? [] : ['Nieprawidłowy format email']
};
};
const minLength = (min: number): Validator<string> => (value: string) => {
const isValid = value.length >= min;
return {
isValid,
errors: isValid ? [] : [`Minimum ${min} znaków wymagane`]
};
};
// Kompozycja walidatorów
const emailValidator = combineValidators(isRequired, isEmail);
const passwordValidator = combineValidators(isRequired, minLength(8));
console.log(emailValidator('jan@example.com')); // { isValid: true, errors: [] }
console.log(emailValidator('')); // { isValid: false, errors: ['Pole jest wymagane', 'Nieprawidłowy format email'] }
console.log(passwordValidator('123')); // { isValid: false, errors: ['Minimum 8 znaków wymagane'] }
// Przetwarzanie danych z kompozycją
interface RawProduct {
name: string;
price: string;
description: string;
tags: string;
}
interface ProcessedProduct {
name: string;
price: number;
description: string;
tags: string[];
slug: string;
}
// Funkcje transformacji
const parsePrice = (product: RawProduct): ProcessedProduct => ({
...product,
price: parseFloat(product.price),
tags: product.tags.split(','), // surowe fragmenty, oczyści je parseTags
slug: ''
});
const parseTags = (product: ProcessedProduct): ProcessedProduct => ({
...product,
tags: product.tags.map(tag => tag.trim()).filter(tag => tag.length > 0)
});
const generateSlug = (product: ProcessedProduct): ProcessedProduct => ({
...product,
slug: product.name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '')
});
const validateProduct = (product: ProcessedProduct): ProcessedProduct => {
if (product.price <= 0) {
throw new Error('Cena musi być większa od 0');
}
if (!product.name.trim()) {
throw new Error('Nazwa produktu jest wymagana');
}
return product;
};
// Kompozycja przetwarzania - parsePrice zmienia typ, więc wywołujemy go przed pipe
const processProduct = (raw: RawProduct): ProcessedProduct => pipe(
parseTags,
generateSlug,
validateProduct
)(parsePrice(raw));
const rawProduct: RawProduct = {
name: 'Super Laptop',
price: '2999.99',
description: 'Najlepszy laptop na rynku',
tags: 'laptop, komputer, elektronika'
};
try {
const processed = processProduct(rawProduct);
console.log('Przetworzony produkt:', processed);
} catch (error) {
console.error('Błąd przetwarzania:', (error as Error).message);
}combineValidators zbiera błędy ze wszystkich walidatorów, a krok zmieniający typ, parsePrice, wywołujemy przed pipe.
Kompozycja asynchroniczna
Potok działa też z obietnicami (Promise). Każdy krok czeka na wynik poprzedniego dzięki then:
// Kompozycja dla funkcji asynchronicznych
const composeAsync = <T>(...functions: Array<(arg: T) => Promise<T>>) => {
return (value: T): Promise<T> => {
return functions.reduceRight<Promise<T>>(
(acc, fn) => acc.then(fn),
Promise.resolve(value)
);
};
};
const pipeAsync = <T>(...functions: Array<(arg: T) => Promise<T>>) => {
return (value: T): Promise<T> => {
return functions.reduce<Promise<T>>(
(acc, fn) => acc.then(fn),
Promise.resolve(value)
);
};
};
// Przykład użycia z API
interface ApiUser {
id: number;
name: string;
email: string;
}
interface EnrichedUser extends ApiUser {
avatar: string;
lastLogin: Date;
preferences: any;
}
// Funkcje asynchroniczne
const fetchUser = async (userId: number): Promise<ApiUser> => {
console.log(`Fetching user ${userId}`);
// Symulacja wywołania API
return new Promise(resolve => {
setTimeout(() => {
resolve({
id: userId,
name: 'Jan Kowalski',
email: 'jan@example.com'
});
}, 100);
});
};
const enrichWithAvatar = async (user: ApiUser): Promise<EnrichedUser> => {
console.log('Enriching with avatar');
return new Promise(resolve => {
setTimeout(() => {
resolve({
...user,
avatar: `https://avatars.example.com/${user.id}`,
lastLogin: new Date(),
preferences: {}
});
}, 50);
});
};
const enrichWithPreferences = async (user: EnrichedUser): Promise<EnrichedUser> => {
console.log('Enriching with preferences');
return new Promise(resolve => {
setTimeout(() => {
resolve({
...user,
preferences: {
theme: 'dark',
language: 'pl',
notifications: true
}
});
}, 50);
});
};
// Kompozycja asynchroniczna - enrichWithAvatar zmienia typ (ApiUser -> EnrichedUser),
// więc wywołujemy go przed potokiem
const enrichUser = (user: ApiUser): Promise<EnrichedUser> =>
enrichWithAvatar(user).then(pipeAsync(enrichWithPreferences));
// Użycie
async function main() {
try {
const user = await fetchUser(1);
const enrichedUser = await enrichUser(user);
console.log('Wzbogacony użytkownik:', enrichedUser);
} catch (error) {
console.error('Błąd:', error);
}
}
main();reduce splata kroki w jeden łańcuch obietnic, zachowując kolejność.
Praktyczny przykład - System e-commerce z programowaniem funkcyjnym
Na koniec wszystko razem: czyste filtry, niemutowalny koszyk, currying i pipe:
// Kompleksowy przykład zastosowania programowania funkcyjnego
// Typy danych
interface Product {
id: string;
name: string;
price: number;
category: string;
tags: string[];
inStock: boolean;
rating: number;
}
interface CartItem {
product: Product;
quantity: number;
}
interface Cart {
items: CartItem[];
discountCode?: string;
}
interface Order {
id: string;
items: CartItem[];
subtotal: number;
discount: number;
tax: number;
total: number;
timestamp: Date;
}
// Czyste funkcje dla produktów
const filterByCategory = (category: string) => (products: Product[]) =>
products.filter(product => product.category === category);
const filterByPriceRange = (min: number, max: number) => (products: Product[]) =>
products.filter(product => product.price >= min && product.price <= max);
const filterInStock = (products: Product[]) =>
products.filter(product => product.inStock);
const sortByPrice = (ascending: boolean = true) => (products: Product[]) =>
[...products].sort((a, b) => ascending ? a.price - b.price : b.price - a.price);
const sortByRating = (products: Product[]) =>
[...products].sort((a, b) => b.rating - a.rating);
// Funkcje dla koszyka
const addToCart = (product: Product, quantity: number) => (cart: Cart): Cart => {
const existingItemIndex = cart.items.findIndex(item => item.product.id === product.id);
if (existingItemIndex >= 0) {
return {
...cart,
items: cart.items.map((item, index) =>
index === existingItemIndex
? { ...item, quantity: item.quantity + quantity }
: item
)
};
}
return {
...cart,
items: [...cart.items, { product, quantity }]
};
};
const removeFromCart = (productId: string) => (cart: Cart): Cart => ({
...cart,
items: cart.items.filter(item => item.product.id !== productId)
});
const updateQuantity = (productId: string, newQuantity: number) => (cart: Cart): Cart => {
if (newQuantity <= 0) {
return removeFromCart(productId)(cart);
}
return {
...cart,
items: cart.items.map(item =>
item.product.id === productId
? { ...item, quantity: newQuantity }
: item
)
};
};
const applyDiscountCode = (discountCode: string) => (cart: Cart): Cart => ({
...cart,
discountCode
});
// Funkcje do obliczania cen
const calculateItemTotal = (item: CartItem): number =>
item.product.price * item.quantity;
const calculateSubtotal = (items: CartItem[]): number =>
items.reduce((total, item) => total + calculateItemTotal(item), 0);
const calculateDiscount = (subtotal: number, discountCode?: string): number => {
const discountRates: Record<string, number> = {
'SAVE10': 0.1,
'SAVE20': 0.2,
'STUDENT': 0.15
};
if (!discountCode || !discountRates[discountCode]) {
return 0;
}
return subtotal * discountRates[discountCode];
};
const calculateTax = (amount: number, taxRate: number = 0.23): number =>
amount * taxRate;
const calculateTotal = (subtotal: number, discount: number, tax: number): number =>
subtotal - discount + tax;
// Kompozycja dla przetwarzania zamówienia
const processOrder = (cart: Cart): Order => {
const subtotal = calculateSubtotal(cart.items);
const discount = calculateDiscount(subtotal, cart.discountCode);
const taxableAmount = subtotal - discount;
const tax = calculateTax(taxableAmount);
const total = calculateTotal(subtotal, discount, tax);
return {
id: 'order_' + Math.random().toString(36).slice(2, 11),
items: cart.items,
subtotal,
discount,
tax,
total,
timestamp: new Date()
};
};
// Funkcje wyszukiwania z kompozycją
const searchProducts = (
query: string,
category?: string,
priceRange?: { min: number; max: number },
sortBy: 'price' | 'rating' = 'rating'
) => (products: Product[]): Product[] => {
const searchByName = (products: Product[]) =>
products.filter(product =>
product.name.toLowerCase().includes(query.toLowerCase()) ||
product.tags.some(tag => tag.toLowerCase().includes(query.toLowerCase()))
);
const filters = [
searchByName,
filterInStock
];
if (category) {
filters.push(filterByCategory(category));
}
if (priceRange) {
filters.push(filterByPriceRange(priceRange.min, priceRange.max));
}
const sorter = sortBy === 'price' ? sortByPrice() : sortByRating;
return pipe(...filters, sorter)(products);
};
// Przykład użycia
const products: Product[] = [
{
id: '1',
name: 'Laptop Gaming',
price: 3500,
category: 'electronics',
tags: ['gaming', 'laptop', 'high-performance'],
inStock: true,
rating: 4.8
},
{
id: '2',
name: 'Mysz Gamingowa',
price: 150,
category: 'electronics',
tags: ['gaming', 'mouse', 'rgb'],
inStock: true,
rating: 4.5
},
{
id: '3',
name: 'Książka JavaScript',
price: 89,
category: 'books',
tags: ['programming', 'javascript', 'learning'],
inStock: false,
rating: 4.9
}
];
// Tworzenie koszyka funkcyjnie
const emptyCart: Cart = { items: [] };
const myCart = pipe(
addToCart(products[0], 1),
addToCart(products[1], 2),
applyDiscountCode('SAVE10')
)(emptyCart);
console.log('Koszyk:', myCart);
// Przetwarzanie zamówienia
const order = processOrder(myCart);
console.log('Zamówienie:', order);
// Wyszukiwanie produktów
const searchGaming = searchProducts('gaming', 'electronics', undefined, 'price');
const gamingProducts = searchGaming(products);
console.log('Produkty gaming:', gamingProducts);
// Częściowe zastosowanie: produkt ustalony, ilość podajemy później
const addLaptopToCart = (quantity: number) => addToCart(products[0], quantity);
const addMouseToCart = (quantity: number) => addToCart(products[1], quantity);
const cartWithLaptop = addLaptopToCart(1)(emptyCart);
const cartWithBoth = addMouseToCart(2)(cartWithLaptop);
console.log('Koszyk z laptopem i myszką:', cartWithBoth);Koszyk nigdy nie jest modyfikowany: każda operacja zwraca nową wersję.
Podsumowanie programowania funkcyjnego
- Czyste funkcje - przewidywalność i łatwość testowania
- Niemutowalność - bezpieczeństwo i brak efektów ubocznych
- Currying - elastyczność i ponowne wykorzystanie
- Kompozycja - budowanie złożonej logiki z prostych elementów
Zyskujesz przewidywalny kod, łatwe testy jednostkowe, lepsze warunki do przetwarzania równoległego i mniej błędów mutacji stanu. Styl funkcyjny błyszczy w transformacjach danych, obliczeniach, systemach wymagających niezawodności i często testowanym kodzie. W edytorze poniżej zbudujesz rejestr dinozaurów, a w kolejnej lekcji czyste funkcje wrócą jako reducery.
"Czysta funkcja to laboratorium z zamkniętymi drzwiami: wchodzą argumenty, wychodzi wynik" - mówi Dr. Rex.
Kod do tej lekcji: index.js
// Wzorzec Factory - Rejestr Dinozaurów
// Ćwiczenie: Zaimplementuj fabrykę i rejestr dinozaurów
class Dinosaur {
constructor(name, species, diet) {
this.name = name;
this.species = species;
this.diet = diet;
this.health = 100;
}
getInfo() {
return this.name + " (" + this.species + ") - " + this.diet;
}
}
class DinosaurRegistry {
constructor() {
this.dinosaurs = [];
}
// Zaimplementuj metody:
// create(name, species, diet) - tworzy i rejestruje dinozaura
// findBySpecies(species) - szuka po gatunku
// getAll() - zwraca wszystkie
create(name, species, diet) {
// Twój kod tutaj
}
findBySpecies(species) {
// Twój kod tutaj
}
}
const registry = new DinosaurRegistry();
console.log("Rejestr dinozaurów gotowy");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. Kiedy najlepiej użyć wzorca Observer?
2. Co to jest higher-order function (funkcja wyższego rzędu)?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
W pliku index.js jest klasa DinosaurRegistry z metodami register, update i find. Uzupełnij luki: ___BLANK1___ kopiuje wszystkie pola starego rekordu do nowego obiektu (tak jak w lekcji o niemutowalności), ___BLANK2___ to metoda tablicy, która zostawia tylko pasujące rekordy, a ___BLANK3___ to metoda tablicy, która zwraca true dopiero wtedy, gdy rekord spełnia każde kryterium. update ma zwrócić nowy obiekt i nie zmieniać starego, a find({ zone: 'A', species: 'T-Rex' }) tylko rekordy spełniające oba warunki.
- Klikanie w kolejności
Ułóż elementy prostej fabryki (wzorzec Factory) w odpowiedniej kolejności:
- Edytor kodu
W pliku index.js jest klasa SecuritySystem z sensorami i obserwatorami (wzorzec Observer). Uzupełnij luki: ___BLANK1___ to metoda tablicy, która dopisuje obserwatora w subscribe, ___BLANK2___ to metoda obserwatora, którą notify wywołuje z alertem, a ___BLANK3___ to operator porównania, przez który alert dostaje tylko sensor z odczytem większym niż próg (odczyt równy progowi nie jest alarmem). checkAlerts ma zwrócić alerty { sensorId, zone, value } i powiadomić o każdym wszystkich obserwatorów, a triggerEmergencyProtocol(reason) włączyć tryb awaryjny i wysłać obserwatorom alert { type: 'emergency', reason }.