Referencje, kopiowanie i mutowalność

// prymitywy: niezależne kopie
let x = 5;
let y = x;
y = 7;
console.log(x, y);                 // 5 7

let imie = 'Ala';
let imie2 = imie;
imie2 += 'n';
console.log(imie, imie2);          // Ala Alan

// obiekty: jedna rzecz, dwie etykiety
const a = { punkty: 10 };
const b = a;
b.punkty = 99;
console.log(a.punkty, b.punkty);   // 99 99
console.log(a === b);              // true – ta sama referencja

// tablice to też obiekty
const lista = ['mleko'];
const taSama = lista;
taSama.push('chleb');
console.log(lista);                // ['mleko', 'chleb']

let a = { x: 1 };
let b = a;

b = { x: 2 };        // PRZYPISANIE: b dostaje nową strzałkę do nowego obiektu
console.log(a.x);    // 1 – stary obiekt nietknięty, a dalej na niego wskazuje

b.x = 3;             // MUTACJA nowego obiektu
console.log(a.x);    // 1 – a nie ma z nim nic wspólnego
console.log(a === b); // false

function zmien(obiekt, liczba) {
  obiekt.imie = 'ZMIENIONE';   // mutacja – widoczna na zewnątrz
  liczba = 0;                  // przypisanie – lokalne
  obiekt = { imie: 'NOWY' };   // przypisanie – też lokalne! od tej chwili obiekt to inna etykieta
  obiekt.imie = 'NOWY2';       // mutacja NOWEGO obiektu – oryginał tego nie widzi
}

const uczen = { imie: 'Ala' };
let wiek = 17;
zmien(uczen, wiek);
console.log(uczen.imie, wiek);   // ZMIENIONE 17

const ustawienia = { motyw: 'jasny' };
ustawienia.motyw = 'ciemny';   // OK – mutacja
ustawienia.jezyk = 'pl';       // OK – nowa właściwość
console.log(ustawienia);

const oceny = [4, 5];
oceny.push(3);                 // OK
console.log(oceny);

oceny = [];                    // TypeError: Assignment to constant variable.

const CENNIK = Object.freeze({
  bilet: 26,
  ulgowy: 18,
  dodatki: ['popcorn', 'napój'],
});

CENNIK.bilet = 1;          // w tym trybie: ignorowane bez błędu (w module byłby TypeError)
CENNIK.nowy = 100;         // ignorowane
delete CENNIK.ulgowy;      // ignorowane
console.log(CENNIK.bilet, CENNIK.nowy, CENNIK.ulgowy, Object.isFrozen(CENNIK));

CENNIK.dodatki.push('nachosy'); // zagnieżdżona tablica NIE jest zamrożona
console.log(CENNIK.dodatki);

console.log({} === {});                 // false – dwa różne obiekty
console.log([1, 2] === [1, 2]);         // false
console.log('ab' === 'ab');             // true – prymitywy porównywane po wartości

const a = { x: 1 };
const b = a;
console.log(a === b);                   // true – ta sama referencja

// porównanie zawartości (płaskie obiekty)
function taSamaZawartosc(o1, o2) {
  const k1 = Object.keys(o1);
  const k2 = Object.keys(o2);
  return k1.length === k2.length && k1.every((k) => o1[k] === o2[k]);
}
console.log(taSamaZawartosc({ x: 1, y: 2 }, { y: 2, x: 1 })); // true
console.log(taSamaZawartosc({ x: 1 }, { x: 1, y: 2 }));       // false

// sztuczka z JSON – uwaga na kolejność kluczy
console.log(JSON.stringify({ x: 1, y: 2 }) === JSON.stringify({ y: 2, x: 1 })); // false!

const wyniki = [12, 45, 7];
const ranking = { oryginal: wyniki, posortowane: wyniki.sort((a, b) => b - a) };

// sort zmutował tablicę, na którą wskazują oba pola – „oryginał” też jest posortowany
console.log(ranking.oryginal, ranking.posortowane, ranking.oryginal === ranking.posortowane);

// poprawnie: toSorted (lub [...wyniki].sort) tworzy nową tablicę
const dane = [12, 45, 7];
const bezMutacji = { oryginal: dane, posortowane: dane.toSorted((a, b) => b - a) };
console.log(bezMutacji.oryginal, bezMutacji.posortowane);

const uczen = { imie: 'Ala', oceny: [5, 4] };
const kopia = { ...uczen };

console.log(kopia === uczen);               // false – nowy obiekt zewnętrzny
console.log(kopia.oceny === uczen.oceny);   // true  – wspólna tablica!

kopia.imie = 'Ola';
kopia.oceny.push(3);
console.log(uczen.imie, uczen.oceny);       // Ala [5, 4, 3]

// jak zmienić zagnieżdżenie bez dotykania oryginału? Skopiuj też wnętrze:
const bezpieczna = { ...uczen, oceny: [...uczen.oceny, 6] };
console.log(uczen.oceny, bezpieczna.oceny); // [5, 4, 3] [5, 4, 3, 6]

const zamowienie = {
  nr: 1,
  klient: { imie: 'Ewa', adres: { miasto: 'Łódź' } },
  pozycje: [{ nazwa: 'Kabel', ilosc: 2 }],
  data: new Date('2026-10-20'),
};

const kopia = structuredClone(zamowienie);
kopia.klient.adres.miasto = 'Gdańsk';
kopia.pozycje[0].ilosc = 99;
kopia.pozycje.push({ nazwa: 'Mysz', ilosc: 1 });

console.log(zamowienie.klient.adres.miasto, zamowienie.pozycje.length, zamowienie.pozycje[0].ilosc); // Łódź 1 2
console.log(kopia.klient.adres.miasto, kopia.pozycje.length);                                     // Gdańsk 2
console.log(kopia.data.getFullYear(), kopia.data !== zamowienie.data);                             // 2026 true – data skopiowana jako Date, nie napis

const zMetoda = { nazwa: 'x', pokaz() { return this.nazwa; } };
structuredClone(zMetoda); // DataCloneError: pokaz() { … } could not be cloned

// WERSJA ZEPSUTA: historia trzyma referencje do jednej tablicy
let lista = [];
const historia = [];

function dodaj(produkt) {
  historia.push(lista);     // zapisujemy „stan przed” – ale to ta sama tablica…
  lista.push(produkt);      // …którą zaraz mutujemy
}
dodaj('mleko');
dodaj('chleb');
console.log(historia.map((h) => h.join(','))); // obie wersje identyczne – historia bezużyteczna

// WERSJA POPRAWNA: nowy stan zamiast mutacji
let lista2 = [];
const historia2 = [];

function dodaj2(produkt) {
  historia2.push(lista2);          // stara tablica zostaje nietknięta…
  lista2 = [...lista2, produkt];   // …bo tworzymy nową
}
dodaj2('mleko');
dodaj2('chleb');
console.log(historia2.map((h) => h.join(',') || '(pusto)'), lista2);