Leaks vermeiden – Closures, Timer und Referenzen
Speicherlecks verhindern, indem Timer gelöscht, Closures begrenzt und nicht benötigte Referenzen entfernt werden; kleine, einsteigerfreundliche Muster verwenden
Leaks vermeiden – Closures, Timer und Referenzen ist eine kostenlose JavaScript Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. 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 3 Lektionen.
Was ist ein Leak?
Ziel: Vermeiden Sie einfache Speicherlecks.
- Timer immer löschen
- Keine ungenutzten Referenzen behalten
- Closures klein halten
- Kurzlebige Daten bevorzugen

Intervalle löschen
Speichern Sie die id des Intervalls. Rufen Sie bei der Bereinigung clearInterval auf, damit der Timer und die von ihm eingeschlossenen Werte freigegeben werden können.
// Start an interval and then clear it to avoid leaks
function startTicker() {
// store id so we can clear later
const id = setInterval(function () {
// work would run every X ms; omitted for demo
}, 1000);
// simulate screen close / cleanup
clearInterval(id);
console.log("interval cleared");
}
startTicker();

Kleinere Closures
Closures behalten alles, was sie einschließen. Schließen Sie nach Möglichkeit kleine Werte statt ganzer Objekte ein.
// Avoid capturing large objects when only small data is needed
function makeReporter(bigArray) {
// BAD: store the whole array inside the closure
const large = bigArray;
return function reportLength() {
// Only the length is used
return large.length;
};
}
// BETTER: capture only what you need
function makeReporterBetter(bigArray) {
const count = bigArray.length; // small number
return function reportLength() {
return count;
};
}
const arr = new Array(1000).fill(0);
const bad = makeReporter(arr);
const good = makeReporterBetter(arr);
console.log("bad:", bad(), "good:", good());

Puffer begrenzen
Langlebige Arrays und Maps können Speicherlecks verursachen, wenn sie unbegrenzt wachsen. Kürzen oder setzen Sie sie zurück regelmäßig.
// A growing buffer can leak if never trimmed or reset
const buffer = []; // module-level array
function logItem(x) {
buffer.push(x); // grows forever if not managed
}
// Simulate usage
logItem("a");
logItem("b");
// FIX: trim or reset when size is over a limit
function trimBuffer(limit) {
if (buffer.length > limit) {
buffer.length = limit; // drop old items
}
}
trimBuffer(1);
console.log("buffer size:", buffer.length);

WeakMap in der Praxis
WeakMap eignet sich, um Metadaten zuzuordnen, ohne die Garbage Collection des Schlüsselobjekts zu verhindern.
// WeakMap holds keys weakly: when the object is gone, the entry can be collected
const meta = new WeakMap();
function attachMeta(obj, info) {
meta.set(obj, info);
}
function readMeta(obj) {
return meta.get(obj); // undefined if not set or collected
}
let user = { name: "Ayla" };
attachMeta(user, { seen: true });
console.log("meta now:", readMeta(user));
// Later: drop the only strong reference
user = null; // after this, the object and its metadata can be GC'd at some point
console.log("object reference dropped (cannot show GC in console)");

Gewohnheiten zur Leckvermeidung
Checkliste:
- Speichern Sie Timer-IDs und rufen Sie bei der Bereinigung clearInterval/clearTimeout auf.
- Schließen Sie in Closures nur benötigte Werte ein.
- Kürzen/setzen Sie zurück langlebige Arrays und Maps.
- Bevorzugen Sie kurzlebige Daten und entfernen Sie Referenzen, sobald sie nicht mehr benötigt werden.

Quiz zur Timer-Bereinigung
Schnelltest: Timer und Speicherlecks.

Zusammenfassung
Zusammenfassung: Löschen Sie Timer, vermeiden Sie es, riesige Objekte in Closures einzuschließen, und kürzen oder entfernen Sie langlebige Referenzen. Kleine Bereinigungen verhindern Speicherlecks in anfängerfreundlichen Anwendungen.

Häufig gestellte Fragen
Ist die Lektion „Leaks vermeiden – Closures, Timer und Referenzen“ kostenlos?
Ja — der vollständige Text von „Leaks vermeiden – Closures, Timer und Referenzen“ 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 3 Lektionen.
Was lerne ich in „Leaks vermeiden – Closures, Timer und Referenzen“?
Speicherlecks verhindern, indem Timer gelöscht, Closures begrenzt und nicht benötigte Referenzen entfernt werden; kleine, einsteigerfreundliche Muster verwenden 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 3.
Wie lange dauert die Lektion „Leaks vermeiden – Closures, Timer und Referenzen“?
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
- Big-O-Grundlagen, Hot Paths vs. Cold Paths (erste Erfolge)
- Leaks vermeiden – Closures, Timer und Referenzen
- Profiling-Einstieg (Node/DevTools) – kleine Timing-Gewohnheiten