JavaScript Academy · Lekcja

Prywatne zmienne za pomocą domknięć

Proszę ukrywać stan w zakresie funkcji.

Prywatne zmienne za pomocą domknięć to bezpłatna lekcja JavaScript Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej JavaScript Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs JavaScript Academy zawiera 4 lekcji w sumie.

Prywatność dzięki domknięciom

JavaScript przez długi czas nie miał wbudowanego sposobu na tworzenie prywatnych pól obiektów. Domknięcia zapewniają takie rozwiązanie: zmienne wewnątrz funkcji są niewidoczne z zewnątrz, ale dostępne dla funkcji zdefiniowanych wewnątrz niej.

function secretBox() {
  let secret = "hidden";
  return {
    reveal: () => secret
  };
}
const box = secretBox();
console.log(box.reveal()); // "hidden"
console.log(box.secret);   // undefined

Licznik z prywatnym stanem

Klasyczny przykład: licznik, którego wartości nie można bezpośrednio zmienić w niepożądany sposób. Zmieniać ją mogą tylko zwrócone metody.

function makeCounter() {
  let count = 0;
  return {
    increment: () => ++count,
    value: () => count
  };
}
const c = makeCounter();
c.increment();
c.increment();
console.log(c.value()); // 2

Stan jest niedostępny

Z zewnątrz nie ma żadnego sposobu, aby uzyskać dostęp do count. Próby odczytania tej wartości zwracają undefined; należy korzystać z metod.

function makeCounter() {
  let count = 0;
  return { inc: () => ++count, get: () => count };
}
const c = makeCounter();
c.count = 100;        // creates an unrelated property
console.log(c.get()); // 0 - real count untouched

Egzekwowanie reguł

Ponieważ dostęp odbywa się przez metody, mogą Państwo egzekwować niezmienniki, na przykład nie dopuszczać do tego, aby saldo stało się ujemne.

function account(start) {
  let balance = start;
  return {
    withdraw: (n) => {
      if (n > balance) return "insufficient";
      balance -= n;
      return balance;
    },
    balance: () => balance
  };
}
const a = account(100);
console.log(a.withdraw(150)); // "insufficient"
console.log(a.withdraw(40));  // 60

Wiele prywatnych pól

Domknięcie może chronić jednocześnie kilka zmiennych. Wszystkie pozostają ukryte i są współdzielone wyłącznie przez zwrócone metody.

function user(name) {
  let logins = 0;
  let lastSeen = null;
  return {
    login: () => { logins++; lastSeen = "now"; },
    stats: () => ({ name, logins, lastSeen })
  };
}
const u = user("Ada");
u.login();
console.log(u.stats()); // { name: "Ada", logins: 1, lastSeen: "now" }

Prywatne funkcje pomocnicze

Nie dotyczy to tylko danych — można ukrywać także funkcje wewnętrzne. Publiczne są wyłącznie metody, które zostaną udostępnione.

function temperature() {
  let celsius = 0;
  const toF = (c) => c * 9 / 5 + 32; // private
  return {
    set: (c) => { celsius = c; },
    fahrenheit: () => toF(celsius)
  };
}
const t = temperature();
t.set(100);
console.log(t.fahrenheit()); // 212

Niezależne instancje

Każde wywołanie funkcji fabrykującej tworzy oddzielny prywatny stan, więc instancje nigdy nie wpływają na siebie nawzajem.

function makeCounter() {
  let n = 0;
  return { inc: () => ++n };
}
const a = makeCounter();
const b = makeCounter();
console.log(a.inc(), a.inc()); // 1 2
console.log(b.inc());          // 1

Udostępnianie tylko do odczytu

Udostępnienie gettera bez settera sprawia, że wartość jest tylko do odczytu z zewnątrz, a jednocześnie nadal można ją zmieniać wewnętrznie.

function timer() {
  let ticks = 0;
  setupInternally();
  function setupInternally() { ticks = 3; }
  return { ticks: () => ticks };
}
const t = timer();
console.log(t.ticks()); // 3 - no way to set it outside

Porównanie: pola klas

Współczesny JavaScript obsługuje także prywatne pola klas #private. Domknięcia pozostają przydatne w funkcjach fabrykujących oraz wtedy, gdy chcą Państwo zapewnić prywatność bez używania klas.

class Counter {
  #count = 0;
  inc() { return ++this.#count; }
}
const c = new Counter();
console.log(c.inc()); // 1

Dlaczego to działa

Zwrócone metody są domknięciami obejmującymi zmienne zewnętrzne. Funkcja zewnętrzna zakończyła działanie, ale jej zakres nadal istnieje, ponieważ te domknięcia wciąż się do niego odwołują.

Pamięć podręczna memoizacji

Prywatny stan świetnie sprawdza się w pamięciach podręcznych. Obiekt pamięci podręcznej pozostaje ukryty i zachowuje się między wywołaniami.

function memoSquare() {
  const cache = {};
  return (n) => {
    if (cache[n] === undefined) cache[n] = n * n;
    return cache[n];
  };
}
const sq = memoSquare();
console.log(sq(4)); // 16
console.log(sq(4)); // 16 (cached)

Szybkie sprawdzenie

Prywatne zmienne z użyciem domknięć.

Podsumowanie

Domknięcia zapewniają prywatność: zmienne wewnątrz funkcji fabrykującej są niedostępne z zewnątrz, ale współdzielone przez zwrócone metody. Umożliwia to tworzenie liczników odpornych na niepożądane modyfikacje, sald z niezmiennikami, ukrytych funkcji pomocniczych i pamięci podręcznych. Każde wywołanie funkcji fabrykującej tworzy niezależny stan. Współczesne prywatne pola klas #private stanowią alternatywę, ale domknięcia szczególnie dobrze sprawdzają się w kodzie opartym na funkcjach fabrykujących.

Często zadawane pytania

Czy lekcja „Prywatne zmienne za pomocą domknięć” jest bezpłatna?

Tak — pełny tekst „Prywatne zmienne za pomocą domknięć” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu JavaScript Academy, przejdź na CoddyKit PRO. Kurs JavaScript Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Prywatne zmienne za pomocą domknięć”?

Proszę ukrywać stan w zakresie funkcji. Ćwiczysz JavaScript Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć JavaScript Academy?

Nie wymagamy żadnego doświadczenia. JavaScript Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Prywatne zmienne za pomocą domknięć”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji JavaScript Academy?

Tak. Każda lekcja JavaScript Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do JavaScript Academy