Kurs JavaScript i TypeScript · Moduł 12: Programowanie funkcyjne
Projekt: Funkcyjny pipeline danych Parku Jurajskiego
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:
- Parsowanie - wczytanie surowych danych z sensorów
- Walidacja - sprawdzenie poprawności danych (Maybe/Either)
- Transformacja - przetworzenie danych (map, filter)
- Agregacja - podsumowania i statystyki (reduce)
- 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?