function stackoverflow http - Wie funktionieren JavaScript-Verschlüsse?




15 Answers

Wenn Sie das Funktionsschlüsselwort in einer anderen Funktion sehen, hat die innere Funktion Zugriff auf Variablen in der äußeren Funktion.

function foo(x) {
  var tmp = 3;

  function bar(y) {
    console.log(x + y + (++tmp)); // will log 16
  }

  bar(10);
}

foo(2);

Dies wird immer 16 protokollieren, da bar auf das x zugreifen kann, das als Argument für foo , und es kann auch von foo auf tmp zugreifen.

Das ist eine Schließung. Eine Funktion muss nicht zurückkehren , um als Schließung bezeichnet zu werden. Durch den einfachen Zugriff auf Variablen außerhalb Ihres unmittelbaren lexikalischen Bereichs wird eine Schließung erstellt .

function foo(x) {
  var tmp = 3;

  return function (y) {
    console.log(x + y + (++tmp)); // will also log 16
  }
}

var bar = foo(2); // bar is now a closure.
bar(10);

Die obige Funktion protokolliert auch 16, da der bar immer noch auf x und tmp verweisen kann, obwohl er sich nicht mehr direkt im Gültigkeitsbereich befindet.

Da tmp jedoch immer noch im Verschluss der bar hängt, wird es ebenfalls inkrementiert. Sie wird bei jedem Aufruf der bar inkrementiert.

Das einfachste Beispiel für einen Abschluss ist:

var a = 10;

function test() {
  console.log(a); // will output 10
  console.log(b); // will output 6
}
var b = 6;
test();

Wenn eine JavaScript-Funktion aufgerufen wird, wird ein neuer Ausführungskontext erstellt. Dieser Ausführungskontext empfängt zusammen mit den Funktionsargumenten und dem übergeordneten Objekt auch alle außerhalb davon deklarierten Variablen (im obigen Beispiel sowohl 'a' als auch 'b').

Es ist möglich, mehr als eine Schließungsfunktion zu erstellen, indem Sie entweder eine Liste von ihnen zurückgeben oder sie auf globale Variablen setzen. Alle beziehen sich auf dasselbe x und das gleiche tmp . Sie erstellen keine eigenen Kopien.

Hier ist die Zahl x eine Literalzahl. Wie bei anderen Literalen in JavaScript wird beim Aufruf von foo die Zahl x als Argument x in foo kopiert .

Andererseits verwendet JavaScript immer Referenzen, wenn es um Objekte geht. Wenn Sie beispielsweise foo mit einem Objekt aufgerufen haben, referenziert die zurückgegebene Schließung dieses ursprüngliche Objekt!

function foo(x) {
  var tmp = 3;

  return function (y) {
    console.log(x + y + tmp);
    x.memb = x.memb ? x.memb + 1 : 1;
    console.log(x.memb);
  }
}

var age = new Number(2);
var bar = foo(age); // bar is now a closure referencing age.
bar(10);

Wie erwartet, wird jeder Aufruf von bar(10) x.memb erhöht. Was nicht erwartet werden kann, ist, dass x sich auf dasselbe Objekt bezieht wie die Altersvariable! Nach ein paar Telefonanrufen wird age.memb 2 Jahre age.memb ! Diese Referenzierung ist die Basis für Speicherverluste bei HTML-Objekten.

javascript function variables scope closures

Wie würden Sie JavaScript-Verschlüsse jemandem erklären, der die Konzepte kennt, aus denen er besteht (z. B. Funktionen, Variablen und dergleichen), die Verschlüsse jedoch selbst nicht verstehen?

Ich habe das Beispielschema von Wikipedia gesehen, aber es hat leider nicht geholfen.




Wenn wir die Frage ernst nehmen, sollten wir herausfinden, wozu ein typischer Sechsjähriger kognitiv fähig ist, obgleich jemand, der sich für JavaScript interessiert, nicht so typisch ist.

Zur Entwicklung der Kindheit: 5 bis 7 Jahre heißt es:

Ihr Kind kann in zwei Schritten folgen. Wenn Sie beispielsweise zu Ihrem Kind sagen: "Gehen Sie in die Küche und holen Sie mir einen Müllsack", kann sich diese Richtung merken.

Wir können dieses Beispiel verwenden, um Schließungen wie folgt zu erklären:

Die Küche ist eine Schließung mit einer lokalen Variablen, die als trashBags . In der Küche gibt es eine Funktion namens getTrashBag , die einen Müllsack erhält und ihn zurückgibt.

Wir können dies in JavaScript wie folgt codieren:

function makeKitchen() {
  var trashBags = ['A', 'B', 'C']; // only 3 at first

  return {
    getTrashBag: function() {
      return trashBags.pop();
    }
  };
}

var kitchen = makeKitchen();

console.log(kitchen.getTrashBag()); // returns trash bag C
console.log(kitchen.getTrashBag()); // returns trash bag B
console.log(kitchen.getTrashBag()); // returns trash bag A

Weitere Punkte, die erklären, warum Schließungen interessant sind:

  • Bei jedem makeKitchen() wird ein neuer Abschluss mit eigenen trashBags .
  • Die trashBags Variable befindet sich lokal in jeder Küche und ist außerhalb nicht zugänglich. Die innere Funktion der getTrashBag Eigenschaft hat jedoch Zugriff darauf.
  • Jeder Funktionsaufruf erzeugt eine Schließung, aber es besteht keine Notwendigkeit, die Schließung herumzuhalten, es sei denn, eine innere Funktion, die Zugang zum Inneren der Schließung hat, kann außerhalb der Schließung aufgerufen werden. Die Rückgabe des Objekts mit der Funktion getTrashBag erfolgt hier.



Verschlüsse sind schwer zu erklären, da sie dazu dienen, Verhaltensweisen zu schaffen, von denen jeder intuitiv erwartet, dass sie trotzdem funktionieren. Ich finde, der beste Weg, sie zu erklären (und die Art und Weise, wie ich gelernt habe, was sie tun) ist, sich die Situation ohne sie vorzustellen:

    var bind = function(x) {
        return function(y) { return x + y; };
    }
    
    var plus5 = bind(5);
    console.log(plus5(3));

Was würde hier passieren, wenn JavaScript keine Schließungen kennt? Ersetzen Sie einfach den Aufruf in der letzten Zeile durch seinen Methodenkörper (was Funktionsaufrufe grundsätzlich tun), und Sie erhalten Folgendes:

console.log(x + 3);

Wo ist die Definition von x ? Wir haben es im aktuellen Umfang nicht definiert. Die einzige Lösung besteht darin, dass plus5 seinen Geltungsbereich (oder vielmehr den Geltungsbereich des übergeordneten plus5 tragen lässt . Auf diese Weise ist x klar definiert und an den Wert 5 gebunden.




OK, 6 Jahre alter Ventilator. Möchten Sie das einfachste Beispiel für die Schließung hören?

Stellen wir uns die nächste Situation vor: Ein Fahrer sitzt im Auto. Das Auto ist in einem Flugzeug. Flugzeug ist im Flughafen. Die Möglichkeit des Fahrers, auf Dinge außerhalb seines Autos zuzugreifen, aber innerhalb des Flugzeugs, selbst wenn das Flugzeug einen Flughafen verlässt, ist eine Schließung. Das ist es.Wenn Sie 27 Jahre alt sind, schauen Sie sich die detailliertere Erklärung oder das Beispiel unten an.

So kann ich meine Flugzeuggeschichte in Code umwandeln.

var plane = function(defaultAirport) {

  var lastAirportLeft = defaultAirport;

  var car = {
    driver: {
      startAccessPlaneInfo: function() {
        setInterval(function() {
          console.log("Last airport was " + lastAirportLeft);
        }, 2000);
      }
    }
  };
  car.driver.startAccessPlaneInfo();

  return {
    leaveTheAirport: function(airPortName) {
      lastAirportLeft = airPortName;
    }
  }
}("Boryspil International Airport");

plane.leaveTheAirport("John F. Kennedy");




Ich habe vor einiger Zeit einen Blogbeitrag geschrieben, der die Schließungen erklärt. Hier ist , was ich sagte , über Schließungen in Bezug auf , warum Sie ein wünschen würde.

Schließungen sind eine Möglichkeit, eine Funktion über persistente, private Variablen zu verfügen , d. H. Variablen , von denen nur eine Funktion weiß, wo sie Informationen aus früheren Zeiten nachverfolgen können.

In diesem Sinne lassen sie eine Funktion wie ein Objekt mit privaten Attributen wirken.

Vollständiger Beitrag:

Also, was sind diese Verschlusssachen?




Wie würde ich es einem Sechsjährigen erklären:

Sie wissen, wie Erwachsene ein Haus besitzen können, und sie nennen es Zuhause? Wenn eine Mutter ein Kind hat, besitzt das Kind wirklich nichts, oder? Aber seine Eltern besitzen ein Haus. Wenn also jemand das Kind fragt "Wo ist dein Zuhause?", Kann er / sie "das Haus!" Beantworten und auf das Haus seiner Eltern zeigen. Eine "Schließung" ist die Fähigkeit des Kindes, immer (auch wenn im Ausland) sagen zu können, dass es ein Zuhause hat, obwohl es eigentlich die Eltern sind, die das Haus besitzen.




Ich lerne in der Regel besser durch gute / schlechte Vergleiche. Ich möchte gerne Arbeitscode, gefolgt von nicht funktionierendem Code, dem jemand begegnet. Ich habe ein jsFiddle zusammengestellt , das einen Vergleich durchführt und versucht, die Unterschiede auf die einfachsten Erklärungen zu reduzieren , die mir einfallen könnten.

Schließungen richtig gemacht:

console.log('CLOSURES DONE RIGHT');

var arr = [];

function createClosure(n) {
    return function () {
        return 'n = ' + n;
    }
}

for (var index = 0; index < 10; index++) {
    arr[index] = createClosure(index);
}

for (var index in arr) {
    console.log(arr[index]());
}
  • In dem obigen Code createClosure(n)wird in jeder Iteration der Schleife Code aufgerufen. Beachten Sie, dass ich die Variable benannt habe, num hervorzuheben, dass es sich um eine neue Variable handelt, die in einem neuen Funktionsbereich erstellt wurde, und nicht die Variable indexist, die an den äußeren Bereich gebunden ist.

  • Dies schafft einen neuen Bereich und nist an diesen Bereich gebunden. Das heißt, wir haben 10 separate Bereiche, einen für jede Iteration.

  • createClosure(n) gibt eine Funktion zurück, die das n innerhalb dieses Bereichs zurückgibt.

  • Innerhalb jedes Bereichs nist der Wert an den Wert gebunden, zu dem es createClosure(n)aufgerufen wurde, sodass die verschachtelte Funktion, die zurückgegeben wird, immer den Wert desjenigen zurückgibt n, zu dem sie createClosure(n)aufgerufen wurde.

Abschlüsse falsch gemacht:

console.log('CLOSURES DONE WRONG');

function createClosureArray() {
    var badArr = [];

    for (var index = 0; index < 10; index++) {
        badArr[index] = function () {
            return 'n = ' + index;
        };
    }
    return badArr;
}

var badArr = createClosureArray();

for (var index in badArr) {
    console.log(badArr[index]());
}
  • Im obigen Code wurde die Schleife innerhalb der createClosureArray()Funktion verschoben und die Funktion gibt jetzt nur das vollständige Array zurück, was auf den ersten Blick intuitiver erscheint.

  • Was nicht offensichtlich ist, ist, dass, da createClosureArray()nur einmal aufgerufen wird, nur ein Gültigkeitsbereich für diese Funktion erstellt wird, anstatt einen für jede Iteration der Schleife.

  • Innerhalb dieser Funktion wird eine Variable mit dem Namen indexdefiniert. Die Schleife wird ausgeführt und fügt dem Array zurückgegebene Funktionen hinzu index. Beachten Sie, dass dies indexinnerhalb der createClosureArrayFunktion definiert ist, die immer nur einmal aufgerufen wird.

  • Da es nur einen Bereich innerhalb der createClosureArray()Funktion gab, indexist er nur an einen Wert innerhalb dieses Bereichs gebunden. Mit anderen Worten, jedes Mal, wenn die Schleife den Wert ändert index, ändert sie den Wert für alles, was auf diesen Bereich innerhalb dieses Bereichs verweist.

  • Alle dem Array hinzugefügten Funktionen geben die SAME- indexVariable aus dem übergeordneten Bereich zurück, in der sie definiert wurde, anstelle von 10 verschiedenen aus 10 verschiedenen Bereichen, wie im ersten Beispiel. Das Endergebnis ist, dass alle 10 Funktionen dieselbe Variable aus demselben Bereich zurückgeben.

  • Nachdem die Schleife beendet und indexdie Änderung abgeschlossen war, war der Endwert 10, daher gibt jede zum Array hinzugefügte Funktion den Wert der einzelnen indexVariablen zurück, die jetzt auf 10 gesetzt ist.

Ergebnis

SCHLIESSUNGEN NACH RECHTS
n = 0
n = 1
n = 2
n = 3
n = 4
n = 5
n = 6
n = 7
n = 8
n = 9

VERSCHLÜSSE VERSCHLÜSSE
n = 10
n = 10
n = 10
n = 10
n = 10
n = 10
n = 10
n = 10
n = 10
n = 10




Ich habe ein interaktives JavaScript-Tutorial zusammengestellt, um zu erklären, wie Schließungen funktionieren. Was ist eine Schließung?

Hier ist eines der Beispiele:

var create = function (x) {
    var f = function () {
        return x; // We can refer to x here!
    };
    return f;
};
// 'create' takes one argument, creates a function

var g = create(42);
// g is a function that takes no arguments now

var y = g();
// y is 42 here



Ich verstehe nicht, warum die Antworten hier so komplex sind.

Hier ist eine Schließung:

var a = 42;

function b() { return a; }

Ja. Sie verwenden wahrscheinlich so oft am Tag.


Es gibt keinen Grund zu der Annahme, dass Schließungen ein komplexer Design-Hack sind, um spezifische Probleme anzugehen. Nein, bei Closures wird nur eine Variable verwendet, die aus einem höheren Bereich stammt, wenn die Funktion deklariert wurde (nicht ausgeführt) .

Nun , was es ermöglicht , was Sie tun können spektakuläre, Andere Antworten sein.




Ein Abschluss ist, wenn eine innere Funktion in ihrer äußeren Funktion auf Variablen zugreifen kann. Dies ist wahrscheinlich die einfachste einzeilige Erklärung, die Sie für Schließungen erhalten können.




Du schläfst ein und du lädst Dan ein. Du sagst Dan, er soll einen XBox-Controller mitbringen.

Dan lädt Paul ein. Dan bittet Paul, einen Controller mitzubringen. Wie viele Controller wurden zur Party gebracht?

function sleepOver(howManyControllersToBring) {

    var numberOfDansControllers = howManyControllersToBring;

    return function danInvitedPaul(numberOfPaulsControllers) {
        var totalControllers = numberOfDansControllers + numberOfPaulsControllers;
        return totalControllers;
    }
}

var howManyControllersToBring = 1;

var inviteDan = sleepOver(howManyControllersToBring);

// The only reason Paul was invited is because Dan was invited. 
// So we set Paul's invitation = Dan's invitation.

var danInvitedPaul = inviteDan(howManyControllersToBring);

alert("There were " + danInvitedPaul + " controllers brought to the party.");



Der Autor von Closures hat Schließungen ziemlich gut erklärt, den Grund erklärt, warum wir sie brauchen, und auch LexicalEnvironment, das zum Verständnis von Schließungen notwendig ist.
Hier ist die Zusammenfassung:

Was ist, wenn auf eine Variable zugegriffen wird, diese aber nicht lokal ist? Wie hier:

In diesem Fall findet der Interpreter die Variable im äußeren LexicalEnvironmentObjekt.

Der Prozess besteht aus zwei Schritten:

  1. Wenn eine Funktion f erstellt wird, wird sie nicht in einem leeren Bereich erstellt. Es gibt ein aktuelles LexicalEnvironment-Objekt. Im obigen Fall ist es das Fenster (a ist zum Zeitpunkt der Funktionserstellung undefiniert).

Wenn eine Funktion erstellt wird, erhält sie eine verborgene Eigenschaft namens [[Scope]], die auf die aktuelle LexicalEnvironment verweist.

Wenn eine Variable gelesen wird, aber nirgendwo gefunden werden kann, wird ein Fehler generiert.

Verschachtelte Funktionen

Funktionen können ineinander verschachtelt werden und bilden eine Kette von LexicalEnvironments, die auch als Scope-Chain bezeichnet werden kann.

Funktion g hat also Zugriff auf g, a und f.

Verschlüsse

Eine verschachtelte Funktion kann weiterleben, nachdem die äußere Funktion abgeschlossen ist:

Markieren von Lexikalischen Umgebungen:

Wie wir sehen, this.sayist eine Eigenschaft im Benutzerobjekt, also lebt es weiter, nachdem der Benutzer abgeschlossen ist.

Wenn Sie sich erinnern, wann sie this.sayerstellt wird, erhält sie (wie jede Funktion) einen internen Verweis this.say.[[Scope]]auf die aktuelle LexicalEnvironment. Die LexicalEnvironment der aktuellen User-Ausführung bleibt also im Speicher. Alle Variablen des Benutzers sind auch seine Eigenschaften. Daher werden sie auch sorgfältig aufbewahrt und nicht wie üblich als Junk-Objekte verwendet.

Es geht darum, sicherzustellen, dass die innere Funktion in der Lage ist, auf eine äußere Variable zuzugreifen.

Zusammenfassen:

  1. Die innere Funktion enthält einen Verweis auf die äußere LexicalEnvironment.
  2. Die innere Funktion kann jederzeit auf Variablen von ihr zugreifen, auch wenn die äußere Funktion beendet ist.
  3. Der Browser speichert die LexicalEnvironment und alle ihre Eigenschaften (Variablen) im Speicher, bis eine innere Funktion vorhanden ist, die auf sie verweist.

Dies wird als Schließung bezeichnet.




Okay, im Gespräch mit einem 6-jährigen Kind würde ich möglicherweise folgende Assoziationen verwenden.

Stellen Sie sich vor, Sie spielen mit Ihren kleinen Brüdern und Schwestern im gesamten Haus, und Sie bewegen sich mit Ihren Spielsachen herum und bringen einige von ihnen in das Zimmer Ihres älteren Bruders. Nach einer Weile kam Ihr Bruder von der Schule zurück und ging in sein Zimmer, und er sperrte ihn ein, so dass Sie jetzt keine direkten Spielsachen mehr finden konnten. Aber Sie könnten an die Tür klopfen und Ihren Bruder nach dem Spielzeug fragen. Dies wird als Schließung von Spielzeug bezeichnet . Ihr Bruder hat es für Sie gemacht, und er ist jetzt in äußerster Reichweite .

Vergleichen Sie es mit einer Situation, in der eine Tür durch Zugluft gesperrt wurde und sich niemand darin befand (allgemeine Funktionsausführung). Dann kommt es zu örtlichen Bränden, die den Raum niederbrennen (Garbage Collector: D). Dann wurde ein neuer Raum errichtet und Sie können jetzt gehen ein anderes Spielzeug dort (neue Funktionsinstanz), aber nie die gleichen Spielsachen bekommen, die in der ersten Rauminstanz übrig waren.

Für ein fortgeschrittenes Kind würde ich etwas wie das Folgende setzen. Es ist nicht perfekt, aber man fühlt, was es ist:

function playingInBrothersRoom (withToys) {
  // We closure toys which we played in the brother's room. When he come back and lock the door
  // your brother is supposed to be into the outer [[scope]] object now. Thanks god you could communicate with him.
  var closureToys = withToys || [],
      returnToy, countIt, toy; // Just another closure helpers, for brother's inner use.

  var brotherGivesToyBack = function (toy) {
    // New request. There is not yet closureToys on brother's hand yet. Give him a time.
    returnToy = null;
    if (toy && closureToys.length > 0) { // If we ask for a specific toy, the brother is going to search for it.

      for ( countIt = closureToys.length; countIt; countIt--) {
        if (closureToys[countIt - 1] == toy) {
          returnToy = 'Take your ' + closureToys.splice(countIt - 1, 1) + ', little boy!';
          break;
        }
      }
      returnToy = returnToy || 'Hey, I could not find any ' + toy + ' here. Look for it in another room.';
    }
    else if (closureToys.length > 0) { // Otherwise, just give back everything he has in the room.
      returnToy = 'Behold! ' + closureToys.join(', ') + '.';
      closureToys = [];
    }
    else {
      returnToy = 'Hey, lil shrimp, I gave you everything!';
    }
    console.log(returnToy);
  }
  return brotherGivesToyBack;
}
// You are playing in the house, including the brother's room.
var toys = ['teddybear', 'car', 'jumpingrope'],
    askBrotherForClosuredToy = playingInBrothersRoom(toys);

// The door is locked, and the brother came from the school. You could not cheat and take it out directly.
console.log(askBrotherForClosuredToy.closureToys); // Undefined

// But you could ask your brother politely, to give it back.
askBrotherForClosuredToy('teddybear'); // Hooray, here it is, teddybear
askBrotherForClosuredToy('ball'); // The brother would not be able to find it.
askBrotherForClosuredToy(); // The brother gives you all the rest
askBrotherForClosuredToy(); // Nothing left in there

Wie Sie sehen, sind die im Zimmer verbleibenden Spielsachen immer noch über den Bruder zugänglich, unabhängig davon, ob der Raum abgeschlossen ist. Hier ist ein Jsbin , um damit zu spielen.




Eine Funktion in JavaScript ist nicht nur ein Verweis auf eine Reihe von Anweisungen (wie in der Sprache C), sondern enthält auch eine verborgene Datenstruktur, die aus Verweisen auf alle nichtlokalen Variablen besteht, die sie verwendet (erfasste Variablen). Solche zweiteiligen Funktionen werden Schließungen genannt. Jede Funktion in JavaScript kann als Schließung betrachtet werden.

Verschlüsse sind Funktionen mit einem Zustand. "This" ist etwas ähnlich in dem Sinne, dass "this" auch Status für eine Funktion bereitstellt, aber Funktion und "this" sind separate Objekte ("this" ist nur ein ausgefallener Parameter und die einzige Möglichkeit, es dauerhaft an ein Objekt zu binden Funktion ist, einen Abschluss zu erstellen). Während "dieses" und die Funktion immer getrennt voneinander leben, kann eine Funktion nicht von ihrer Schließung getrennt werden, und die Sprache bietet keine Möglichkeit, auf erfasste Variablen zuzugreifen.

Da alle diese externen Variablen, auf die von einer lexikalisch verschachtelten Funktion verwiesen wird, tatsächlich lokale Variablen in der Kette ihrer lexikalisch einschließenden Funktionen sind (globale Variablen können lokale Variablen einer Wurzelfunktion sein), und bei jeder einzelnen Ausführung einer Funktion werden neue Instanzen von erstellt Bei den lokalen Variablen folgt, dass bei jeder Ausführung einer Funktion, die eine verschachtelte Funktion zurückgibt (oder sie anderweitig überträgt, z. B. als Callback registriert), eine neue Schließung (mit ihrem eigenen, möglicherweise eindeutigen Satz von referenzierten nichtlokalen Variablen, die ihre Ausführung darstellen) erstellt wird Kontext).

Es muss auch verstanden werden, dass lokale Variablen in JavaScript nicht auf dem Stapelrahmen erstellt werden, sondern auf dem Heap und nur dann zerstört werden, wenn niemand auf sie verweist. Wenn eine Funktion zurückgegeben wird, werden Verweise auf ihre lokalen Variablen dekrementiert. Sie können jedoch immer noch nicht null sein, wenn sie während der aktuellen Ausführung Teil eines Abschlusses wurden und immer noch von ihren lexikalisch verschachtelten Funktionen referenziert werden (was nur möglich ist, wenn auf die Verweise Bezug genommen wird Diese verschachtelten Funktionen wurden zurückgegeben oder anderweitig in einen externen Code übertragen.

Ein Beispiel:

function foo (initValue) {
   //This variable is not destroyed when the foo function exits.
   //It is 'captured' by the two nested functions returned below.
   var value = initValue;

   //Note that the two returned functions are created right now.
   //If the foo function is called again, it will return
   //new functions referencing a different 'value' variable.
   return {
       getValue: function () { return value; },
       setValue: function (newValue) { value = newValue; }
   }
}

function bar () {
    //foo sets its local variable 'value' to 5 and returns an object with
    //two functions still referencing that local variable
    var obj = foo(5);

    //Extracting functions just to show that no 'this' is involved here
    var getValue = obj.getValue;
    var setValue = obj.setValue;

    alert(getValue()); //Displays 5
    setValue(10);
    alert(getValue()); //Displays 10

    //At this point getValue and setValue functions are destroyed
    //(in reality they are destroyed at the next iteration of the garbage collector).
    //The local variable 'value' in the foo is no longer referenced by
    //anything and is destroyed too.
}

bar();



Ich würde sie einfach auf die Mozilla Closures-Seite verweisen . Es ist die beste, prägnanteste und einfachste Erklärung der Grundlagen und praktischen Anwendung, die ich gefunden habe. Es wird dringend jedem empfohlen, der JavaScript lernt.

Und ja, ich würde es sogar einem Sechsjährigen empfehlen - wenn der Sechsjährige von Schließungen erfährt, ist es logisch, dass sie bereit sind, die kurze und einfache Erklärung zu verstehen, die in dem Artikel enthalten ist.




Related