Kurs JavaScript i TypeScript · Moduł 12: Programowanie funkcyjne

Wzorce niemutowalności danych

6 min czytania ·
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 obiekt

Pola 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 100

Object.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łytki

Zamroż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. 1. Co robi operator spread (...) z zagnieżdżonymi obiektami?

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

  1. Zadanie z kodemNiemutowalne operacje na danych
  2. PytanieSpread operator i obiekty
  3. PytanieGłębokość kopiowania obiektów
  4. Ułóż w kolejnościTechniki niemutowalności od prostych do zaawansowanych
  5. Zadanie z kodemKompletny pipeline FP
  6. Kliknij w kolejnościSkładnia Object.freeze
  7. Ułóż w kolejnościSkładnia niemutowalnej aktualizacji tablicy
  8. Kliknij w kolejnościSkładnia niemutowalnego dodawania do tablicy

Przydatne artykuły