JavaScript Academy · Lektion

Factory-Funktionen

Erstellen Sie mithilfe von Closures Objekte mit privatem Zustand.

Factory-Funktionen ist eine kostenlose JavaScript Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des JavaScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der JavaScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist eine Factory-Funktion

Eine Factory-Funktion ist jede Funktion, die ein neues Objekt zurückgibt. Anders als einen Konstruktor rufen Sie sie normal auf, also ohne new, und sie kann Closures für privaten Zustand verwenden.

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

Kein new-Schlüsselwort

Factories vermeiden die Fallstricke von new und this. Sie rufen die Funktion einfach auf und erhalten ein Objekt zurück.

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

Privater Zustand per Closure

In der Factory deklarierte Variablen sind privat. Die Methoden des zurückgegebenen Objekts schließen sie ein – genau wie beim Module Pattern, erzeugen aber mehrere Instanzen.

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

Viele unabhängige Instanzen

Jeder Aufruf der Factory erzeugt ein neues Objekt mit eigenem privaten Zustand. Das ist der entscheidende Unterschied zu einem Singleton-Modul.

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

Berechnete Eigenschaften

Factories können Werte bei der Erstellung ableiten und berechnete Methoden bereitstellen, während die Eingaben privat bleiben.

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

Standardwerte und optionale Konfiguration

Da es sich um gewöhnliche Funktionen handelt, verarbeiten Factories Standardwerte und Optionen mithilfe von Destrukturierung auf übersichtliche Weise.

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 }

Komposition statt Vererbung

Factories bevorzugen Komposition: Sie erstellen ein Objekt, indem Sie Verhaltensweisen kombinieren, statt eine Klassenhierarchie zu erweitern.

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"

Gemeinsam genutztes Verhalten

Um Methoden ohne Kopien pro Instanz gemeinsam zu nutzen, definieren Sie sie einmal und weisen sie zu. Oder nehmen Sie die geringen Kosten für den Privatsphäre-Vorteil in Kauf, den Closures bieten.

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

Auch Funktionen zurückgeben

Eine Factory kann statt eines Objekts auch eine Funktion zurückgeben, wenn das die übersichtlichere Schnittstelle ist, und dabei weiterhin privaten Zustand erfassen.

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

Factory und Konstruktor im Vergleich

Konstruktoren verwenden new, this und die Prototypenkette. Factories sind einfacher, vermeiden this-Fehler und bieten durch Closures echte Privatsphäre. Dafür teilen sie Methoden nicht über einen Prototyp.

Validierung bei der Erstellung

Factories können Eingaben validieren sowie vor der Rückgabe einen Fehler auslösen oder Werte normalisieren. Dadurch ist garantiert, dass jedes erzeugte Objekt gültig ist.

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

Kurztest

Factory-Funktionen.

Zusammenfassung

Factory-Funktionen geben Objekte ohne new oder this zurück und verwenden Closures für privaten Zustand. Jeder Aufruf erzeugt eine unabhängige Instanz und unterstützt berechnete Eigenschaften, Standardkonfiguration, Komposition und Validierung. Sie verzichten auf das Teilen von Methoden über Prototypen zugunsten von Einfachheit und echter Privatsphäre und sind damit eine klare, von Closures unterstützte Alternative zu Konstruktoren.

Häufig gestellte Fragen

Ist die Lektion „Factory-Funktionen“ kostenlos?

Ja — der vollständige Text von „Factory-Funktionen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des JavaScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der JavaScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Factory-Funktionen“?

Erstellen Sie mithilfe von Closures Objekte mit privatem Zustand. Du übst JavaScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um JavaScript Academy zu starten?

Keine Vorkenntnisse erforderlich. JavaScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Factory-Funktionen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser JavaScript Academy-Lektion Code schreiben und ausführen?

Ja. Jede JavaScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu JavaScript Academy