JavaScript Academy · Lektion

Private Variablen mit Closures

Verbergen Sie Zustand hinter einem Funktions-Scope.

Private Variablen mit Closures ist eine kostenlose JavaScript Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Privatsphäre durch Closures

JavaScript fehlte lange eine integrierte Möglichkeit, Objektfelder privat zu machen. Closures bieten eine solche Möglichkeit: Variablen innerhalb einer Funktion sind von außen unsichtbar, für darin definierte Funktionen aber zugänglich.

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

Ein Zähler mit privatem Zustand

Das klassische Beispiel: ein Zähler, dessen Zählerstand nicht direkt manipuliert werden kann. Nur die zurückgegebenen Methoden können ihn ändern.

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

Der Zustand ist unzugänglich

Von außen gibt es keine Möglichkeit, auf count zuzugreifen. Versuche, den Wert zu lesen, liefern undefined. Sie müssen die Methoden verwenden.

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

Regeln durchsetzen

Da der Zugriff über Methoden erfolgt, können Sie Invarianten durchsetzen, etwa dass ein Kontostand niemals negativ wird.

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

Mehrere private Felder

Eine Closure kann mehrere Variablen gleichzeitig schützen. Sie sind alle verborgen und werden nur von den zurückgegebenen Methoden gemeinsam verwendet.

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" }

Private Hilfsfunktionen

Nicht nur Daten lassen sich verbergen, sondern auch interne Funktionen. Nur die Methoden, die Sie bereitstellen, sind öffentlich.

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

Unabhängige Instanzen

Jeder Aufruf der Factory erzeugt einen eigenen privaten Zustand, sodass sich die Instanzen niemals gegenseitig beeinflussen.

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

Schreibgeschütztes Bereitstellen

Stellen Sie einen Getter ohne Setter bereit, um einen Wert von außen schreibgeschützt, intern aber weiterhin veränderbar zu machen.

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

Vergleich: Klassenfelder

Modernes JavaScript unterstützt auch #private-Klassenfelder. Closures bleiben für Factory-Funktionen und für Privatsphäre ohne Klassen nützlich.

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

Warum es funktioniert

Die zurückgegebenen Methoden sind Closures über den äußeren Variablen. Die äußere Funktion ist zwar zurückgekehrt, aber ihr Gültigkeitsbereich bleibt bestehen, weil diese Closures weiterhin darauf verweisen.

Ein Memoization-Cache

Privater Zustand eignet sich hervorragend für Caches. Das Cache-Objekt bleibt verborgen und bleibt zwischen den Aufrufen erhalten.

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)

Kurztest

Private Variablen mit Closures.

Zusammenfassung

Closures schaffen Privatsphäre: Variablen innerhalb einer Factory sind von außen nicht erreichbar, werden aber von den zurückgegebenen Methoden gemeinsam verwendet. Das ermöglicht manipulationssichere Zähler, Kontostände mit Invarianten, verborgene Hilfsfunktionen und Caches. Jeder Aufruf der Factory erzeugt einen unabhängigen Zustand. Moderne #private-Klassenfelder sind eine Alternative, aber Closures eignen sich besonders für Code im Factory-Stil.

Häufig gestellte Fragen

Ist die Lektion „Private Variablen mit Closures“ kostenlos?

Ja — der vollständige Text von „Private Variablen mit Closures“ 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 „Private Variablen mit Closures“?

Verbergen Sie Zustand hinter einem Funktions-Scope. 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 2 von 4.

Wie lange dauert die Lektion „Private Variablen mit Closures“?

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