JavaScript Academy · Lekcja

Funkcje fabrykujące

Proszę tworzyć obiekty z prywatnym stanem za pomocą domknięć.

Funkcje fabrykujące to bezpłatna lekcja JavaScript Academy na CoddyKit. To lekcja 4 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.

Czym jest funkcja fabrykująca

Funkcja fabrykująca to dowolna funkcja, która zwraca nowy obiekt. W przeciwieństwie do konstruktora wywołuje się ją normalnie, bez new, a do przechowywania prywatnego stanu może ona używać domknięć.

function createUser(name) {
  return {
    name,
    greet: () => "Hi, I am " + name
  };
}
const u = createUser("Ada");
console.log(u.greet()); // "Hi, I am Ada"

Bez słowa kluczowego new

Funkcje fabrykujące pozwalają uniknąć pułapek związanych z new i this. Wystarczy wywołać funkcję, aby otrzymać obiekt.

function point(x, y) {
  return { x, y };
}
const p = point(3, 4);
console.log(p.x, p.y); // 3 4

Prywatny stan dzięki domknięciu

Zmienne zadeklarowane w funkcji fabrykującej są prywatne. Metody zwracanego obiektu obejmują je domknięciem, podobnie jak we wzorcu modułu, ale tworzą wiele instancji.

function createCounter() {
  let count = 0; // private
  return {
    inc: () => ++count,
    get: () => count
  };
}
const c = createCounter();
c.inc();
console.log(c.get()); // 1

Wiele niezależnych instancji

Każde wywołanie funkcji fabrykującej tworzy nowy obiekt z własnym prywatnym stanem. To kluczowa różnica w porównaniu z modułem będącym singletonem.

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

Właściwości obliczane

Funkcje fabrykujące mogą obliczać wartości podczas tworzenia obiektu i udostępniać metody zwracające obliczone wyniki, zachowując dane wejściowe jako prywatne.

function rectangle(w, h) {
  return {
    area: () => w * h,
    perimeter: () => 2 * (w + h)
  };
}
const r = rectangle(3, 4);
console.log(r.area());      // 12
console.log(r.perimeter()); // 14

Konfiguracja domyślna i opcjonalna

Ponieważ są zwykłymi funkcjami, funkcje fabrykujące pozwalają wygodnie obsługiwać wartości domyślne i opcje za pomocą destrukturyzacji.

function createButton({ label = "OK", disabled = false } = {}) {
  return { label, disabled };
}
console.log(createButton());             // { label: "OK", disabled: false }
console.log(createButton({ label: "Go" })); // { label: "Go", disabled: false }

Kompozycja zamiast dziedziczenia

Funkcje fabrykujące sprzyjają kompozycji: obiekt buduje się przez łączenie zachowań zamiast rozszerzania hierarchii klas.

const canFly = (s) => ({ fly: () => s.name + " flies" });
function createBird(name) {
  const self = { name };
  return Object.assign(self, canFly(self));
}
console.log(createBird("Robin").fly()); // "Robin flies"

Współdzielone zachowanie

Aby współdzielić metody między instancjami bez tworzenia ich kopii dla każdej instancji, należy zdefiniować je raz i przypisać. Można też zaakceptować niewielki koszt w zamian za prywatność zapewnianą przez domknięcia.

const behavior = {
  describe() { return "id " + this.id; }
};
function createItem(id) {
  return Object.assign({ id }, behavior);
}
console.log(createItem(7).describe()); // "id 7"

Zwracanie również funkcji

Funkcja fabrykująca może zwracać funkcję zamiast obiektu, jeśli jest to przejrzystszy interfejs, nadal przechwytując prywatny stan.

function multiplier(factor) {
  return (n) => n * factor;
}
const triple = multiplier(3);
console.log(triple(5)); // 15

Funkcja fabrykująca a konstruktor

Konstruktory korzystają z new, this i łańcucha prototypów. Funkcje fabrykujące są prostsze, pozwalają uniknąć błędów związanych z this i zapewniają prawdziwą prywatność dzięki domknięciom, ale nie współdzielą metod za pośrednictwem prototypu.

Walidacja podczas tworzenia

Funkcje fabrykujące mogą sprawdzać dane wejściowe, a przed zwróceniem obiektu zgłaszać błąd lub normalizować dane, gwarantując poprawność każdego utworzonego obiektu.

function createAge(value) {
  if (value < 0) throw new Error("age must be >= 0");
  return { value };
}
console.log(createAge(30).value); // 30

Szybkie sprawdzenie

Funkcje fabrykujące.

Podsumowanie

Funkcje fabrykujące zwracają obiekty bez użycia new ani this, wykorzystując domknięcia do przechowywania prywatnego stanu. Każde wywołanie tworzy niezależną instancję, obsługującą właściwości obliczane, domyślną konfigurację, kompozycję i walidację. W zamian za prostotę i prawdziwą prywatność rezygnują ze współdzielenia metod przez prototyp, stanowiąc przejrzystą alternatywę dla konstruktorów opartą na domknięciach.

Często zadawane pytania

Czy lekcja „Funkcje fabrykujące” jest bezpłatna?

Tak — pełny tekst „Funkcje fabrykujące” 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 „Funkcje fabrykujące”?

Proszę tworzyć obiekty z prywatnym stanem za pomocą domknięć. Ć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 4 z 4.

Ile czasu zajmuje lekcja „Funkcje fabrykujące”?

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