Kurs JavaScript i TypeScript · Moduł 9: Wzorce projektowe i architektura

Programowanie funkcyjne w JavaScript/TypeScript

22 min czytania ·
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:

  1. Determinizm - dla tych samych argumentów zawsze zwraca ten sam wynik
  2. 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! 55

memoize 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)); // 30

Każ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

  1. Czyste funkcje - przewidywalność i łatwość testowania
  2. Niemutowalność - bezpieczeństwo i brak efektów ubocznych
  3. Currying - elastyczność i ponowne wykorzystanie
  4. 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. 1. Kiedy najlepiej użyć wzorca Observer?

  2. 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 }.

  1. PytanieWzorzec Observer
  2. PytanieHigher-order functions
  3. PytanieWzorzec Factory
  4. Zadanie z kodemĆwiczenie: Rejestr dinozaurów
  5. Kliknij w kolejnościKolejność: Wzorzec Factory
  6. Zadanie z kodemĆwiczenie: Monitoring bezpieczeństwa

Przydatne artykuły