Kurs JavaScript i TypeScript · Moduł 12: Programowanie funkcyjne
Wzorce niemutowalności danych
W tej lekcji7
Mapa parku i moduł raportów dostają ten sam obiekt stanu. Mapa przesuwa Rexa do strefy B, zmieniając pole bezpośrednio, i nagle raport z porannej zmiany też pokazuje strefę B, choć rano Rex był w A. Współdzielony obiekt zmieniony w jednym miejscu zmienia się wszędzie, gdzie ktoś trzyma do niego odniesienie.
W laboratoriach Parku Jurajskiego obowiązuje surowa zasada - nigdy nie modyfikujesz oryginalnej próbki DNA. Każda zmiana tworzy nową kopię. To samo podejście stosujemy w programowaniu funkcyjnym z danymi - oryginalne struktury pozostają nienaruszone, a każda modyfikacja tworzy nowy obiekt.
Spread operator - kopiowanie i rozszerzanie
Operator spread (...) to podstawowe narzędzie do tworzenia niemutowalnych kopii obiektów i tablic. Zacznijmy od przeniesienia dinozaura do innej strefy:
// Kopiowanie obiektu z modyfikacja
const dinosaur = { name: 'Rex', health: 100, zone: 'A' };
const movedDino = { ...dinosaur, zone: 'B' };
// dinosaur: { name: 'Rex', health: 100, zone: 'A' } - niezmieniony
// movedDino: { name: 'Rex', health: 100, zone: 'B' } - nowy obiektPola zapisane po spreadzie nadpisują skopiowane, więc zone: 'B' wygrywa z zone: 'A'. movedDino i dinosaur to dwa różne obiekty, a raport trzymający dinosaur wciąż widzi strefę A.
Z tablicami postępujemy tak samo: element dodajemy przez spread, a usuwamy przez filter:
// Kopiowanie tablicy z dodaniem elementu
const zones = ['A', 'B', 'C'];
const extendedZones = [...zones, 'D'];
// zones: ['A', 'B', 'C'] - niezmieniona
// extendedZones: ['A', 'B', 'C', 'D']
// Usuwanie elementu z tablicy (bez mutacji)
const dinosaurs = ['Rex', 'Blue', 'Brachio', 'Stego'];
const withoutBlue = dinosaurs.filter((d) => d !== 'Blue');
// dinosaurs: ['Rex', 'Blue', 'Brachio', 'Stego'] - niezmieniona
// withoutBlue: ['Rex', 'Brachio', 'Stego']Żadna z tych operacji nie użyła push ani splice, które zmieniają tablicę w miejscu.
Zagnieżdżone obiekty - głęboka niemutowalność
Spread operator tworzy płytką kopię - zagnieżdżone obiekty nadal są współdzielone! Musisz spreadować na każdym poziomie. Oto stan parku ze strefami w środku i próba kopii jednym spreadem:
const park = {
name: 'Jurassic Park',
zones: {
A: { dinosaurs: ['Rex'], voltage: 10000 },
B: { dinosaurs: ['Brachio'], voltage: 5000 },
},
};
// ŹLE - płytka kopia, zones jest współdzielone
const badCopy = { ...park };
badCopy.zones.A.voltage = 0; // ZMIENIA też oryginał!badCopy to nowy obiekt, ale jego pole zones wskazuje na ten sam obiekt co park.zones. Zmiana napięcia przez kopię jest więc zmianą oryginału, dokładnie jak w historii z mapą i raportem.
Poprawna aktualizacja kopiuje każdy poziom na ścieżce do zmienianego pola. Zakładamy świeży obiekt park, bo linijka z badCopy zdążyła już wyzerować oryginał:
// DOBRZE - głęboka kopia na każdym poziomie
const updatedPark = {
...park,
zones: {
...park.zones,
A: {
...park.zones.A,
voltage: 15000,
},
},
};
// park.zones.A.voltage: 10000 (niezmieniony)
// updatedPark.zones.A.voltage: 15000 (nowy obiekt)Nowe są tylko obiekty na ścieżce: updatedPark, jego zones i strefa A. Strefa B nie została skopiowana, więc updatedPark.zones.B === park.zones.B. To w porządku, bo jej nie zmienialiśmy, a współdzielenie niezmienionych części oszczędza pamięć.
Object.freeze() - zamrażanie obiektów
Object.freeze() zapobiega modyfikacji obiektu w runtime. Próba zmiany jest po cichu ignorowana, a w trybie ścisłym (strict mode) rzuca TypeError. W trybie ścisłym działa każdy moduł ES i każda klasa:
const CONFIG = Object.freeze({
maxDinosaurs: 100,
maxVoltage: 50000,
alertThreshold: 3,
});
CONFIG.maxDinosaurs = 200; // Ignorowane! (lub TypeError w strict mode)
console.log(CONFIG.maxDinosaurs); // nadal 100Object.freeze zwraca ten sam obiekt, tylko zamrożony: nie da się zmienić, dodać ani usunąć jego pól. Jest jednak haczyk, widoczny przy obiekcie z zagnieżdżoną strukturą:
// UWAGA: freeze jest płytki!
const deepConfig = Object.freeze({
zones: { A: { limit: 10 } },
});
deepConfig.zones.A.limit = 999; // TO ZADZIAŁA - freeze jest płytkiZamrożony jest tylko pierwszy poziom. Obiekt zones pozostał zwykłym obiektem, więc żeby zamrozić całość, trzeba rekurencyjnie wywołać Object.freeze na każdym zagnieżdżonym obiekcie.
const to nie freeze
Częste nieporozumienie: skoro CONFIG jest zadeklarowane przez const, po co jeszcze freeze? Bo te dwa mechanizmy chronią zupełnie co innego:
const zone = { id: 'A', voltage: 10000 };
zone.voltage = 0; // działa - const nie chroni zawartości
// zone = { id: 'B' }; // TypeError - const chroni przypisanie
const lockedZone = Object.freeze({ id: 'A', voltage: 10000 });
lockedZone.voltage = 0; // ignorowane (TypeError w strict mode)const blokuje ponowne przypisanie zmiennej, czyli referencję. Object.freeze blokuje zmianę wartości wewnątrz obiektu. Stałą konfigurację chroń obydwoma naraz, tak jak CONFIG.
structuredClone() - głębokie kopiowanie
structuredClone() tworzy głęboką kopię obiektu - wszystkie zagnieżdżone struktury są niezależne. To wygodne, gdy zmieniasz wiele rzeczy głęboko w strukturze:
const original = {
name: 'Jurassic Park',
zones: [
{ id: 'A', dinosaurs: [{ name: 'Rex', health: 100 }] },
{ id: 'B', dinosaurs: [{ name: 'Blue', health: 95 }] },
],
};
const deepCopy = structuredClone(original);
deepCopy.zones[0].dinosaurs[0].health = 50;
console.log(original.zones[0].dinosaurs[0].health); // 100 (niezmieniony!)
console.log(deepCopy.zones[0].dinosaurs[0].health); // 50 (niezależna kopia)Zmiana w kopii nie dotarła do oryginału. structuredClone działa w nowoczesnych przeglądarkach i w Node.js od wersji 17, ale nie skopiuje funkcji (rzuci DataCloneError), a instancje klas zamieni w zwykłe obiekty bez metod. Moja rada: na co dzień kopiuj spreadem tylko ścieżkę, którą zmieniasz, a structuredClone zostaw na chwilę, gdy potrzebujesz w pełni niezależnej kopii danych.
Niemutowalne aktualizacje tablic
Pełny zestaw operacji na tablicach bez mutacji, zebrany na jednej liście dinozaurów:
const dinosaurs = [
{ id: 1, name: 'Rex', health: 100 },
{ id: 2, name: 'Blue', health: 95 },
{ id: 3, name: 'Brachio', health: 88 },
];
// Dodawanie
const added = [...dinosaurs, { id: 4, name: 'Stego', health: 100 }];
// Usuwanie
const removed = dinosaurs.filter((d) => d.id !== 2);
// Aktualizacja
const updated = dinosaurs.map((d) =>
d.id === 1 ? { ...d, health: 80 } : d
);
// Sortowanie (bez mutacji - tworzymy kopie przed sort)
const sorted = [...dinosaurs].sort((a, b) => a.health - b.health);Aktualizacja przez map z operatorem warunkowym to wzorzec, który zobaczysz wszędzie: zmieniony element dostaje nowy obiekt, pozostałe przechodzą bez zmian. Tablicę kopiujemy przed sort, bo sort zmienia ją w miejscu. Od ES2023 masz też gotowe odpowiedniki bez mutacji: toSorted, toReversed, toSpliced i with.
Od prostych technik do bibliotek
Uporządkujmy narzędzia od najprostszego: Object.freeze pilnuje jednego poziomu, spread robi płytką kopię ze zmianą, a structuredClone głęboką kopię. Przy dużych strukturach sięga się po biblioteki. Immutable.js dostarcza trwałe struktury danych (persistent data structures): każda "zmiana" zwraca nową wersję, która współdzieli niezmienione fragmenty z poprzednią. Immer pozwala pisać zwykłe przypisania na szkicu, a potem sam tworzy nową, niemutowalną wersję. Ten sam wzorzec czeka na Ciebie w świecie React, gdzie stan aktualizuje się nową kopią, a nie mutacją.
Pamiętaj: oryginalnej próbki DNA nie ruszasz nigdy - każda zmiana to nowa probówka, a spread, structuredClone i Object.freeze pilnują tej zasady na różnych poziomach.
Kod do tej lekcji: index.js
// Wzorce niemutowalnosci danych
console.log("=== Park Jurajski - Ochrona Oryginalnych Probek ===\n");
// --- PRZYKLAD 1: Spread operator ---
console.log("--- Spread: obiekty ---");
const dino = { name: "Rex", health: 100, zone: "A" };
const moved = { ...dino, zone: "B" };
console.log("Oryginal:", dino);
console.log("Przeniesiony:", moved);
console.log("\n--- Spread: tablice ---");
const zones = ["A", "B", "C"];
const extended = [...zones, "D"];
console.log("Oryginalne:", zones);
console.log("Rozszerzone:", extended);
// --- PRZYKLAD 2: Zagniezdzone obiekty ---
console.log("\n--- Zagniezdzone obiekty ---");
const park = {
name: "Jurassic Park",
zones: {
A: { dinosaurs: ["Rex"], voltage: 10000 },
B: { dinosaurs: ["Brachio"], voltage: 5000 },
},
};
const updatedPark = {
...park,
zones: {
...park.zones,
A: { ...park.zones.A, voltage: 15000 },
},
};
console.log("Oryginal A voltage:", park.zones.A.voltage);
console.log("Updated A voltage:", updatedPark.zones.A.voltage);
console.log("Oryginal B voltage:", park.zones.B.voltage, "(niezmieniony)");
// --- PRZYKLAD 3: Object.freeze ---
console.log("\n--- Object.freeze ---");
const CONFIG = Object.freeze({
maxDinosaurs: 100,
maxVoltage: 50000,
});
CONFIG.maxDinosaurs = 200; // Ignorowane!
console.log("maxDinosaurs:", CONFIG.maxDinosaurs, "(nadal 100)");
// --- PRZYKLAD 4: structuredClone ---
console.log("\n--- structuredClone ---");
const original = {
zones: [{ id: "A", dinos: [{ name: "Rex", hp: 100 }] }],
};
const deepCopy = structuredClone(original);
deepCopy.zones[0].dinos[0].hp = 50;
console.log("Oryginal hp:", original.zones[0].dinos[0].hp, "(niezmieniony!)");
console.log("Kopia hp:", deepCopy.zones[0].dinos[0].hp);
// --- PRZYKLAD 5: Niemutowalne operacje na tablicach ---
console.log("\n--- Niemutowalne operacje ---");
const dinosaurs = [
{ id: 1, name: "Rex", health: 100 },
{ id: 2, name: "Blue", health: 95 },
{ id: 3, name: "Brachio", health: 88 },
];
// Dodawanie
const added = [...dinosaurs, { id: 4, name: "Stego", health: 100 }];
console.log("Dodano (nowa tablica):", added.length, "items");
// Usuwanie
const removed = dinosaurs.filter((d) => d.id !== 2);
console.log("Usunieto Blue:", removed.map((d) => d.name));
// Aktualizacja
const updated = dinosaurs.map((d) =>
d.id === 1 ? { ...d, health: 80 } : d
);
console.log("Updated Rex:", updated[0].health);
console.log("Oryginal Rex:", dinosaurs[0].health, "(niezmieniony!)");
// Sortowanie (niemutowalne)
const sorted = [...dinosaurs].sort((a, b) => a.health - b.health);
console.log("Posortowane:", sorted.map((d) => d.name + ":" + d.health));
console.log("Oryginal:", dinosaurs.map((d) => d.name + ":" + d.health));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. Co robi operator spread (...) z zagnieżdżonymi obiektami?
2. Która metoda kopiowania obiektów w JavaScript tworzy głęboką kopię (deep clone)?
Zadania praktyczne w grze
- Edytor kodu
Dodaj, usuń, zaktualizuj dane w zagnieżdżonych obiektach używając spread operator i filter/map.
- Układanie w pionie
Ułóż techniki zapewniania niemutowalności danych od najprostszej do najbardziej zaawansowanej:
- Edytor kodu
Zbuduj pipeline z walidacją, klasyfikacją alertów, grupowaniem i statystykami.
- Klikanie w kolejności
Ułóż elementy zamrażania obiektu konfiguracyjnego:
- Układanie w poziomie
Ułóż elementy niemutowalnej aktualizacji elementu w tablicy:
- Klikanie w kolejności
Ułóż elementy niemutowalnego dodawania elementu do tablicy:
Zadania po tej lekcji
- Zadanie z kodemNiemutowalne operacje na danych
- PytanieSpread operator i obiekty
- PytanieGłębokość kopiowania obiektów
- Ułóż w kolejnościTechniki niemutowalności od prostych do zaawansowanych
- Zadanie z kodemKompletny pipeline FP
- Kliknij w kolejnościSkładnia Object.freeze
- Ułóż w kolejnościSkładnia niemutowalnej aktualizacji tablicy
- Kliknij w kolejnościSkładnia niemutowalnego dodawania do tablicy