Wann wird dieser Scope/Closure in javaScript mit Garbage Collection gesammelt?

Question

Ich mache einen Kurs, der Umfang/Schließungen durchläuft und erwähnt Garbage Collection kurz. Während des Kurses wird eine Frage gestellt:

Wie lange bleibt das Oszilloskop? Und die Antwort war - bis gibt es keine Hinweise mehr darauf. Yep, also was wir im Grunde gesagt haben war, ist eine Schließung wie eine Referenz auf ein verstecktes Scope-Objekt. Also, solange es eine Funktion gibt, die immer noch eine Schließung über den Bereich hat, wird dieser Bereich umher bleiben. Aber sobald diese Schließung verschwindet, kann der Bereich Müll gesammelt bekommen. "

var sum = function sumHndlr(x, y) { 
    if (y !== undefined) { 
     return x + y; 
    } else { 
     return function(y) { 
      return x + y; 
     } 
    } 
} 

mir also der Hinweis auf die Schließung ist, wenn wir die Funktion der sum Variablen zugewiesen, aber das bedeutet nicht, dass es ewig dauert, oder bin ich den Weg nicht zu verstehen, die js ausführt in Bezug auf den Compiler-Parser usw.?

Answer 1

Sehr kurz, Garbage collection einen Hintergrundprozess der Javascript-Interpreter/virtuellen Maschine ist, die die Erinnerung an Objekten nicht mehr von Ihrem Programm benötigte automatisch befreit.

zum Beispiel, weil du es für ein Ereignis denkst Listener: Wenn Sie einen Ereignis-Listener (normalerweise eine Funktion) von einem Event-Dispatcher entfernen, hat wahrscheinlich kein anderer Teil des Programms einen Verweis auf den Event-Listener. Daher kann und wird der Garbage Collector (zu einer unbekannten Zeit) den Speicher freigeben, der vom Ereignis-Listener belegt wurde.

Da eine Closure auf ein Scope-Objekt verweist, braucht es nicht nur nicht referenziert werden, um einen Closure-Collect-Closure zu erfassen, sondern auch den Scope.

Wenn ich ein bisschen Ihr Beispiel ändern:

/* some stuff ... */ 
function add10(a) { 
    var adder = function (x) { 
    return function(y) { 
     return x + y; 
    } 
    } 

    var sum = adder(10); //creates a closure 
    return sum(a); 
} 

var thirty = add10(20); 

/* Some more stuff ... */ 

Nach add10 genannt wird, obwohl das Programm weiterhin etwas mehr Material auszuführen, kann die Garbage Collector die zur Schließung sum zugehörigen Speicher frei, weil es wird nicht mehr referenziert, noch ist der damit verbundene Bereich.

Während in diesem Beispiel:

/* some stuff ... */ 
function add10AndGet20Adder(a) { 
    var adders = function (x, y) { 
    return [function(z) { 
     return x + z; 
    }, function(z) { 
     return y + z; 
    }] 
    } 

    var sums = adders(10, 20); //creates a closure 
    return [sums[0](a), sums[1]]; 
} 

var result = add10AndGet20Adder(50); 
var sixty = result[0]; 
var add20 = result[1]; 

/* Some more stuff ... */ 

Wenn mehr Material ausgeführt wird, sums[0] nicht mehr Bezug genommen wird, ABERadd20 (sums[1]) hat noch einen Verweis auf den Umfang, die x und y verweist daher keine der beiden Closures in sums kann vom Garbage Collector freigegeben werden, bis add20 vom Programm referenziert wird.

Ich hoffe, das macht es klarer, auch wenn die Beispiele natürlich nirgends echten Code sind. In der Praxis müssen Sie sich nur dann Gedanken darüber machen, wenn Sie ein langlebiges Programm (z. B. eine einseitige Anwendung oder einen Knoten-JS-Server) mit komplizierter Verwendung von Schließungen entwickeln. Andernfalls ist die Speichernutzung der Schließungen wahrscheinlich kein Problem.

Diese SO gibt Frage mehr Details über die Garbage Collection Javascript: What is JavaScript garbage collection?