Closures

Frontend SELF DE
Level 37, Lektion 5
Verfügbar

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:

  1. Lexikalisches Umfeld: Der Kontext, in dem eine Funktion deklariert wurde, einschließlich aller Variablen, die zum Zeitpunkt der Deklaration verfügbar sind.
  2. 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.

JavaScript
    
      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.

JavaScript
    
      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:

JavaScript
    
      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.

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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)
    
  
1
Aufgabe
Frontend SELF DE, Level 37, Lektion 5
Gesperrt
Zähler mit Closure
Zähler mit Closure
1
Aufgabe
Frontend SELF DE, Level 37, Lektion 5
Gesperrt
Private Variablen
Private Variablen
1
Umfrage/Quiz
Date, Timer und Literale, Level 37, Lektion 5
Nicht verfügbar
Date, Timer und Literale
Date, Timer und Literale
Kommentare
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION