6.1 Das Konzept der Closures
Closures sind eines der mächtigsten und wichtigsten Konzepte in JavaScript. Sie erlauben es Funktionen, sich ihr lexikalisches Umfeld zu merken, selbst nachdem sie ausgeführt wurden. In dieser Vorlesung betrachten wir das Konzept der Closures, ihre Besonderheiten und zeigen verschiedene Beispiele ihrer Verwendung.
Closure (Schließung) in JavaScript ist eine Kombination aus einer Funktion und dem lexikalischen Umfeld, in dem diese Funktion deklariert wurde. Eine Closure erlaubt es einer Funktion, sich an Variablen und andere Funktionen aus ihrem äußeren Gültigkeitsbereich zu "erinnern" und auf sie zuzugreifen, selbst nachdem die äußere Funktion ausgeführt wurde.
Hauptmerkmale von Closures:
- Lexikalisches Umfeld: Der Kontext, in dem eine Funktion deklariert wurde, einschließlich aller Variablen, die zum Zeitpunkt der Deklaration verfügbar sind.
- Erhalt des Kontexts: Eine Funktion mit einer Closure kann auch nach der Ausführung der äußeren Funktion auf Variablen aus dem äußeren Gültigkeitsbereich zugreifen.
6.2 Beispiele für Closures
Beispiel 1: Einfaches Closure
In diesem Beispiel hat innerFunction() Zugriff auf die Variable outerVariable aus ihrem äußeren Gültigkeitsbereich, selbst nachdem outerFunction() ausgeführt wurde.
function outerFunction() {
let outerVariable = 'I am from the outer function';
function innerFunction() {
console.log(outerVariable);
}
return innerFunction;
}
const closure = outerFunction();
closure(); // Gibt aus: I am from the outer function
Beispiel 2: Zähler mit Closure
In diesem Beispiel speichert die Zählerfunktion den Wert der Variable count und erhöht ihn bei jedem Aufruf.
function createCounter() {
let count = 0;
return function() {
count++;
return count;
};
}
const counter = createCounter();
console.log(counter()); // Gibt aus: 1
console.log(counter()); // Gibt aus: 2
console.log(counter()); // Gibt aus: 3
Beispiel 3: Closure in einer Schleife
Closures werden oft verwendet, um Werte von Variablen in Schleifen zu speichern.
In diesem Beispiel "merkt" sich jede Funktion im Array arr den Wert der Variable i zum Zeitpunkt ihrer Erstellung, dank dem Block-Scope von let:
function createArrayWithClosures() {
let arr = [];
for (let i = 0; i < 3; i++) {
arr[i] = function() {
console.log(i);
};
}
return arr;
}
const closures = createArrayWithClosures();
closures[0](); // Gibt aus: 0
closures[1](); // Gibt aus: 1
closures[2](); // Gibt aus: 2
6.3 Komplexe Anwendungsfälle von Closures
Beispiel 1: Partielle Anwendung der Funktion (partial application)
Closures erlauben es, teilweise angewendete Funktionen zu erstellen, indem einige Argumente festgehalten werden.
In diesem Beispiel gibt die Funktion multiply() eine Funktion zurück, die das ihr übergebene Argument b mit dem festgehaltenen Argument a multipliziert.
function multiply(a) {
return function(b) {
return a * b;
};
}
const double = multiply(2);
console.log(double(5)); // Gibt aus: 10
console.log(double(10)); // Gibt aus: 20
Beispiel 2: Verbergen von Daten (data hiding)
Closures können verwendet werden, um private Variablen und Methoden zu erstellen.
In diesem Beispiel sind die Variablen _name und _age privat und nur durch die Methoden des Objekts zugänglich:
function createPerson(name, age) {
let _name = name;
let _age = age;
return {
getName: function() {
return _name;
},
getAge: function() {
return _age;
},
setName: function(newName) {
_name = newName;
},
setAge: function(newAge) {
_age = newAge;
}
};
}
const person = createPerson('John', 30);
console.log(person.getName()); // Gibt aus: John
person.setName('Jane');
console.log(person.getName()); // Gibt aus: Jane
console.log(person.getAge()); // Gibt aus: 30
Beispiel 3: Memoisierung
Memoisierung ist eine Optimierungstechnik, bei der die Ergebnisse einer Funktion gespeichert werden, um wiederholte Berechnungen mit denselben Eingaben zu vermeiden.
In diesem Beispiel verwendet die Funktion memoize() ein Closure, um den Cache der berechneten Ergebnisse der Funktion fn() zu speichern:
function memoize(fn) {
const cache = {};
return function(...args) {
const key = JSON.stringify(args);
if (cache[key]) {
return cache[key];
}
const result = fn(...args);
cache[key] = result;
return result;
};
}
function slowFunction(num) {
console.log('Computing...');
return num * 2;
}
const memoizedFunction = memoize(slowFunction);
console.log(memoizedFunction(5)); // Gibt aus: Computing... 10
console.log(memoizedFunction(5)); // Gibt aus: 10 (Ergebnis aus dem Cache)
GO TO FULL VERSION