Kurs JavaScript i TypeScript · Moduł 12: Programowanie funkcyjne

Projekt: Funkcyjny pipeline danych Parku Jurajskiego

6 min czytania ·
W tej lekcji6

Nocna zmiana dostaje setki odczytów z sensorów: ruch, napięcie ogrodzeń, temperatura. Część z nich jest uszkodzona, bo brakuje identyfikatora albo wartość jest ujemna, a kierownik chce rano jednego raportu: które strefy są bezpieczne, a dokąd trzeba wysłać ekipę. Jeden wielki skrypt z pętlami i flagami szybko staje się nie do utrzymania.

Czas połączyć wszystkie techniki programowania funkcyjnego w jeden projekt. Zbudujemy funkcyjny system przetwarzania danych dinozaurów - od surowych odczytów sensorów po gotowe raporty bezpieczeństwa. Każdy etap to czysta funkcja, a cały proces to pipeline złożony z pipe i compose.

Architektura projektu

Nasz system składa się z kilku warstw:

  1. Parsowanie - wczytanie surowych danych z sensorów
  2. Walidacja - sprawdzenie poprawności danych (Maybe/Either)
  3. Transformacja - przetworzenie danych (map, filter)
  4. Agregacja - podsumowania i statystyki (reduce)
  5. Raportowanie - generowanie końcowego raportu

Pracujemy na sześciu odczytach, wśród których celowo ukryliśmy dwie pułapki:

// Struktura danych wejściowych
const sensorReadings = [
  { sensorId: 'S01', zone: 'A', type: 'motion', value: 85, timestamp: 1700000000 },
  { sensorId: 'S02', zone: 'A', type: 'fence', value: 10000, timestamp: 1700000001 },
  { sensorId: 'S03', zone: 'B', type: 'motion', value: 12, timestamp: 1700000002 },
  { sensorId: 'S04', zone: 'B', type: 'temperature', value: 38, timestamp: 1700000003 },
  { sensorId: null, zone: 'C', type: 'motion', value: -5, timestamp: 1700000004 },
  { sensorId: 'S06', zone: 'A', type: 'fence', value: 0, timestamp: 1700000005 },
];

Piąty odczyt nie ma sensorId i ma ujemną wartość - to śmieci, które walidacja musi odrzucić. Szósty to ogrodzenie z napięciem 0: dane poprawne, ale alarmujące. timestamp to czas uniksowy, czyli liczba sekund od 1 stycznia 1970 roku.

Warstwa walidacji z Maybe

Walidator zwraca odczyt albo null, a Maybe z poprzedniej lekcji zamienia null w bezpieczny, pusty pojemnik. Tu wystarczy okrojona wersja z map i getOrElse:

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)); }
  getOrElse(def) { return this.isNothing() ? def : this.value; }
}

const validateReading = (reading) => {
  if (!reading.sensorId) return null;
  if (reading.value < 0) return null;
  return reading;
};

const safeValidate = (reading) =>
  Maybe.of(reading)
    .map(validateReading)
    .getOrElse(null);

safeValidate owija odczyt, przepuszcza go przez walidator i od razu odpakowuje: poprawny odczyt wraca bez zmian, a uszkodzony staje się null. Odczyt S06 przechodzi, bo 0 nie jest wartością ujemną. To celowe uproszczenie, bo dalsze etapy pracują na zwykłych tablicach i null odfiltrujemy jednym filter.

Budowanie pipeline

Najpierw trzy małe, czyste funkcje dla pojedynczego odczytu. Każda przyjmuje jeden odczyt i zwraca nowy obiekt, nie ruszając oryginału:

// Czyste funkcje - każda robi jedną rzecz
const isValidReading = (r) => r !== null;
const enrichWithDate = (r) => ({
  ...r,
  date: new Date(r.timestamp * 1000).toISOString(),
});
const classifyAlert = (r) => ({
  ...r,
  alert: r.type === 'fence' && r.value < 5000 ? 'CRITICAL' :
         r.type === 'motion' && r.value > 80 ? 'WARNING' : 'OK',
});

enrichWithDate mnoży znacznik przez 1000, bo Date liczy w milisekundach, i zapisuje datę w formacie ISO, np. '2023-11-14T22:13:20.000Z'. classifyAlert używa zagnieżdżonego operatora warunkowego: ogrodzenie poniżej 5000 V to CRITICAL, ruch powyżej 80 to WARNING, a reszta OK.

Dwie kolejne funkcje pracują na całej kolekcji. Grupowanie to znany z lekcji o reduce wzorzec z obliczanym kluczem, a statystyki liczymy dla każdej pary [strefa, odczyty] z Object.entries:

// Agregacja per strefa
const groupByZone = (readings) =>
  readings.reduce((groups, r) => ({
    ...groups,
    [r.zone]: [...(groups[r.zone] || []), r],
  }), {});

// Statystyki per strefa
const calculateZoneStats = (grouped) =>
  Object.entries(grouped).map(([zone, readings]) => ({
    zone,
    totalReadings: readings.length,
    alerts: readings.filter((r) => r.alert !== 'OK').length,
    avgValue: readings.reduce((s, r) => s + r.value, 0) / readings.length,
    status: readings.some((r) => r.alert === 'CRITICAL') ? 'DANGER' : 'SAFE',
  }));

some sprawdza, czy choć jeden odczyt w strefie jest krytyczny, i wtedy cała strefa dostaje status DANGER. Uwaga projektowa: avgValue uśrednia razem ruch, wolty i stopnie, co w prawdziwym raporcie nie miałoby sensu. To dobre miejsce na Twoje pierwsze usprawnienie.

Kompletny pipeline z pipe

Teraz składamy wszystko w jedną linię produkcyjną. Kolejność kroków w pipe to dokładnie kolejność ich wykonania:

function pipe(...fns) {
  return (value) => fns.reduce((acc, fn) => fn(acc), value);
}

const generateSecurityReport = pipe(
  // 1. Walidacja każdego odczytu
  (readings) => readings.map(safeValidate),
  // 2. Filtrowanie niepoprawnych
  (readings) => readings.filter(isValidReading),
  // 3. Wzbogacanie o datę
  (readings) => readings.map(enrichWithDate),
  // 4. Klasyfikacja alertów
  (readings) => readings.map(classifyAlert),
  // 5. Grupowanie per strefa
  groupByZone,
  // 6. Statystyki
  calculateZoneStats,
  // 7. Sortowanie - najniebezpieczniejsze pierwsze
  (stats) => [...stats].sort((a, b) => b.alerts - a.alerts),
);

const report = generateSecurityReport(sensorReadings);

Raport ma dwie pozycje. Strefa A: trzy odczyty, dwa alerty (ruch 85 i ogrodzenie 0 V), status DANGER. Strefa B: dwa odczyty, zero alertów, status SAFE. Strefy C nie ma wcale, bo jej jedyny odczyt odpadł na walidacji - w prawdziwym parku milczący sektor to osobny powód do niepokoju. Ostatni krok kopiuje tablicę przed sort, więc nawet sortowanie niczego nie mutuje, a sensorReadings po całym procesie wygląda tak samo jak przed nim.

Rozszerzenie - curried utility functions

Na koniec narzędzia w stylu curried. Konfigurację podajesz najpierw, a tablicę na końcu, więc po skonfigurowaniu każda funkcja pasuje prosto do pipe:

const filterBy = (key) => (value) => (arr) =>
  arr.filter((item) => item[key] === value);

const mapField = (key) => (fn) => (arr) =>
  arr.map((item) => ({ ...item, [key]: fn(item[key]) }));

const filterByZone = filterBy('zone');
const filterZoneA = filterByZone('A');

const normalizeValues = mapField('value')((v) => Math.round(v * 100) / 100);

filterZoneA to gotowy filtr strefy A, a normalizeValues zaokrągla pole value do dwóch miejsc po przecinku w kopii każdego odczytu. Obie funkcje możesz wstawić jako kolejne etapy generateSecurityReport.

Twoje zadanie dla mentora

W edytorze poniżej znajdziesz kompletny, działający projekt do eksploracji i modyfikacji. Zanim wyślesz link mentorowi, rozbuduj go: zamień Maybe na Either, żeby raport wymieniał odrzucone odczyty z powodem, policz średnie osobno dla każdego typu sensora i oznacz strefy, z których nie dotarł żaden poprawny odczyt. Sprawdź też, czy wejście pozostaje nietknięte: zamroź sensorReadings i każdy odczyt przez Object.freeze, a w trybie ścisłym każda próba mutacji rzuci TypeError. Te same wzorce spotkasz w Świecie 2: reducery w Reduxie to czyste funkcje, a stan w React aktualizuje się niemutowalnymi kopiami.

Pamiętaj: dobry pipeline to linia laboratoryjna z małych, czystych stanowisk - każde robi jedną rzecz, żadne nie rusza oryginalnej próbki, a te same dane zawsze dają ten sam raport.

Kod do tej lekcji: index.js
// Projekt: Funkcyjny pipeline danych Parku Jurajskiego
console.log("=== Park Jurajski - Kompletny System Raportowania ===\n");

// --- Maybe monada ---
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)); }
  getOrElse(def) { return this.isNothing() ? def : this.value; }
}

// --- Utility functions ---
function pipe(...fns) {
  return (value) => fns.reduce((acc, fn) => fn(acc), value);
}

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) return fn(...args);
    return (...more) => curried(...args, ...more);
  };
}

const filterBy = curry((field, value, arr) =>
  arr.filter((item) => item[field] === value)
);

// --- Dane wejsciowe (odczyty sensorow) ---
const sensorReadings = [
  { sensorId: "S01", zone: "A", type: "motion", value: 85, ts: 1700000000 },
  { sensorId: "S02", zone: "A", type: "fence", value: 10000, ts: 1700000001 },
  { sensorId: "S03", zone: "B", type: "motion", value: 12, ts: 1700000002 },
  { sensorId: "S04", zone: "B", type: "temperature", value: 38, ts: 1700000003 },
  { sensorId: null, zone: "C", type: "motion", value: -5, ts: 1700000004 },
  { sensorId: "S06", zone: "A", type: "fence", value: 0, ts: 1700000005 },
  { sensorId: "S07", zone: "C", type: "motion", value: 92, ts: 1700000006 },
  { sensorId: "S08", zone: "B", type: "fence", value: 8500, ts: 1700000007 },
];

// --- Warstwa walidacji ---
const validateReading = (reading) =>
  Maybe.of(reading)
    .map((r) => r.sensorId ? r : null)
    .map((r) => r && r.value >= 0 ? r : null)
    .getOrElse(null);

// --- Czyste funkcje transformacji ---
const isValid = (r) => r !== null;

const enrichWithDate = (r) => ({
  ...r,
  date: new Date(r.ts * 1000).toISOString().split("T")[0],
});

const classifyAlert = (r) => ({
  ...r,
  alert: r.type === "fence" && r.value < 5000 ? "CRITICAL"
       : r.type === "motion" && r.value > 80 ? "WARNING"
       : "OK",
});

// --- Agregacja ---
const groupByZone = (readings) =>
  readings.reduce((groups, r) => ({
    ...groups,
    [r.zone]: [...(groups[r.zone] || []), r],
  }), {});

const calculateZoneStats = (grouped) =>
  Object.entries(grouped).map(([zone, readings]) => ({
    zone,
    totalReadings: readings.length,
    criticalAlerts: readings.filter((r) => r.alert === "CRITICAL").length,
    warnings: readings.filter((r) => r.alert === "WARNING").length,
    avgValue: Math.round(readings.reduce((s, r) => s + r.value, 0) / readings.length),
    status: readings.some((r) => r.alert === "CRITICAL") ? "DANGER" : "SAFE",
  }));

// --- Kompletny pipeline ---
const generateSecurityReport = pipe(
  (readings) => readings.map(validateReading),
  (readings) => readings.filter(isValid),
  (readings) => readings.map(enrichWithDate),
  (readings) => readings.map(classifyAlert),
  groupByZone,
  calculateZoneStats,
  (stats) => [...stats].sort((a, b) => b.criticalAlerts - a.criticalAlerts),
);

// --- Uruchomienie ---
console.log("Dane wejsciowe:", sensorReadings.length, "odczytow\n");

const report = generateSecurityReport(sensorReadings);

console.log("=== RAPORT BEZPIECZENSTWA ===\n");
report.forEach((zone) => {
  const icon = zone.status === "DANGER" ? "!!!" : "OK ";
  console.log(`[${icon}] Zone ${zone.zone}:`);
  console.log(`    Odczyty: ${zone.totalReadings}`);
  console.log(`    Krytyczne: ${zone.criticalAlerts}`);
  console.log(`    Ostrzezenia: ${zone.warnings}`);
  console.log(`    Srednia wartosc: ${zone.avgValue}`);
  console.log(`    Status: ${zone.status}\n`);
});

// --- Curried filtrowanie raportu ---
console.log("=== Filtrowane raporty ===\n");

const filterByStatus = filterBy("status");
const dangerZones = filterByStatus("DANGER")(report);
console.log("Strefy DANGER:", dangerZones.map((z) => z.zone));

const safeZones = filterByStatus("SAFE")(report);
console.log("Strefy SAFE:", safeZones.map((z) => z.zone));

// --- Podsumowanie ---
const summary = report.reduce((acc, z) => ({
  totalReadings: acc.totalReadings + z.totalReadings,
  totalCritical: acc.totalCritical + z.criticalAlerts,
  totalWarnings: acc.totalWarnings + z.warnings,
}), { totalReadings: 0, totalCritical: 0, totalWarnings: 0 });

console.log("\n=== PODSUMOWANIE ===");
console.log("Laczne odczyty:", summary.totalReadings);
console.log("Laczne krytyczne:", summary.totalCritical);
console.log("Laczne ostrzezenia:", summary.totalWarnings);

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

  1. Projekt do wysłaniaProjekt do mentora: Moduł 12
  2. WideoPodsumowanie modułu

Przydatne artykuły