Was sind Verschlüsse in Javascript?

Was ist eine Schließung?

Was ist eine Schließung? Schließung, eine neue Funktion, die statische Sprachen nicht haben. Aber der Abschluss ist nicht allzu kompliziert, um ihn zu verstehen. Kurz gesagt, der Abschluss ist eine Sammlung lokaler Variablen der Funktion, aber diese lokalen Variablen bleiben bestehen, nachdem die Funktion zurückgekehrt ist. Schließung bedeutet, dass der „Stapel“ einer Funktion nicht freigegeben wird, nachdem die Funktion zurückgegeben wurde. Wir können auch verstehen, dass diese Funktionsstapel nicht auf dem Stapel, sondern auf dem Heap zugewiesen werden, wenn eine andere Funktion innerhalb einer Funktion definiert wird . Tasche.

Abschluss = Funktion, die innerhalb der Funktion erstellt wurde (oder kurz interne Funktion) + Umgebungsinformationen, als die Funktion erstellt wurde

Abschluss ist also nicht gleichbedeutend mit anonymer Funktion, obwohl manche Leute diese Funktionen The nennen Die intern erstellte Funktion ist eine Abschlussfunktion, aber ich denke, sie ist nicht korrekt.

Sehen wir uns den folgenden Code an:

function init() {
    var name = "Zilongshanren"; // name 是在 init 函数里面创建的变量
    // displayName() 是一个内部函数，即一个闭包。注意，它不是匿名的。
    function displayName() {
        console.log(name);
    }
    //当 displayName 函数返回后，这个函数还能访问 init 函数里面定义的变量。
    return displayName;
}
var closure = init();
closure();
Zilongshanren
undefined

displayName ist eine Funktion, die innerhalb der Init-Funktion erstellt wurde. Sie trägt alle Informationen des internen Bereichs der Init-Funktion, wie z der Name hier. Wenn die Funktion displayName zurückkehrt, trägt sie selbst die Umgebungsinformationen, als sie erstellt wurde, d. h. die Namensvariable in der Funktion init.

Was bewirkt die Schließung?

Nachdem Sie verstanden haben, was ein Verschluss ist, fragen Sie sich vielleicht: Dieses Ding ist so schwer zu verstehen, welchen Nutzen hat es?

Da es in JS keine Möglichkeit gibt, private Methoden zu erstellen, gibt es nicht wie in Java oder C++ das Schlüsselwort private, um private Eigenschaften und Methoden zu definieren. In JS können nur Funktionen Objekte erstellen, die zu ihrem eigenen Bereich gehören. JS hat keinen Blockbereich! Ich werde später einen weiteren Artikel schreiben, um dies im Detail vorzustellen.

Jeder Programmierveteran weiß, dass Kapselung und Abstraktion gut eingesetzt werden müssen, um ein Programm gut zu schreiben! Die Unfähigkeit, private Eigenschaften und Methoden zu definieren, bedeutet, dass Kapselung und Abstraktion überhaupt nicht verwendet werden können. . .

Sie können keine privaten Dinge definieren, alle Variablen und Funktionen sind öffentlich. Es gibt offensichtlich ein Problem: Global ist böse!

Schließungen sind unsere Rettung!

Sehen wir uns den folgenden Code an:

var makeCounter = function() {
    var privateCounter = 0;
    function changeBy(val) {
        privateCounter += val;
    }
    return {
        increment: function() {
            changeBy(1);
        },
        decrement: function() {
            changeBy(-1);
        },
        value: function() {
            return privateCounter;
        }
    }
};
var counter1 = makeCounter();
var counter2 = makeCounter();
console.log(counter1.value()); /* Alerts 0 */
counter1.increment();
counter1.increment();
console.log(counter1.value()); /* Alerts 2 */
counter1.decrement();
console.log(counter1.value()); /* Alerts 1 */
console.log(counter2.value()); /* Alerts 0 */
0
2
1
0
undefined

Die Variable privateCounter und changeBy hier sind privat und für außerhalb der makeCounter-Funktion völlig unsichtbar. Auf diese Weise verbirgt das Objekt, das wir über makeCounter generieren, alle seine privaten Daten und privaten Methoden.

Erinnert dich das an irgendetwas?

Haha, ist das nicht nur OO? Kapseln Sie Daten und Methoden zum Betreiben von Daten und schließen Sie die Datenverarbeitung dann über öffentliche Schnittstellenaufrufe ab.

Natürlich kann man sagen, dass ich OO auch mithilfe der prototypischen Vererbung implementieren kann. Ja, das tun mittlerweile die meisten Menschen, uns eingeschlossen. Allerdings ist Vererbung immer sehr schwer zu verstehen, denn um einen Codeabschnitt zu verstehen, muss man alle seine Vererbungsketten verstehen. Wenn der Code einen Fehler enthält, ist das Debuggen sehr schwierig.

Das ist zu weit. Schauen wir uns als Nächstes an, wie man Verschlüsse richtig verwendet.

Wie verwendet man Verschlüsse richtig?

Schließungen belegen Speicher und wirken sich auch auf die Ausführungseffizienz der js-Engine aus. Wenn ein Codeabschnitt daher häufig ausgeführt wird, sollten Sie die Verwendung von Schließungen in diesem Code sorgfältig in Betracht ziehen.

Sehen wir uns eine Funktion an, die ein Objekt erstellt:

function MyObject(name, message)
 {    this.name = name.toString();  
   this.message = message.toString();   
    this.getName = function()
     {        return this.name;    };   
      this.getMessage = function() 
      {        return this.message;    };}
      var myobj = new MyObject();
var myobj = new MyObject();

Jedes Mal, wenn sie aufgerufen wird, um ein neues Objekt zu generieren, werden zwei Abschlüsse generiert. Wenn Ihr Programm Tausende solcher MyObject-Objekte enthält, wird es viel mehr Speicher beanspruchen.

Der richtige Ansatz sollte darin bestehen, die Prototypenkette zu verwenden:

function MyObject(name, message) {
    this.name = name.toString();
    this.message = message.toString();
}
MyObject.prototype.getName = function() {
    return this.name;
};
MyObject.prototype.getMessage = function() {
    return this.message;
};
var myobj = new MyObject();

Jetzt definiert der MyObject-Prototyp zwei Methoden. Wenn wir ein Objekt über new erstellen, werden diese beiden Methoden nur verwendet Kopie auf dem Prototyp gespeichert.

Wie funktioniert der Abschluss?

Ein Abschluss ist ebenfalls eine Funktion, speichert aber zusätzliche Umgebungsinformationen, sodass er theoretisch mehr Speicher beansprucht als eine reine Funktion und die JS-Engine mehr verbraucht, wenn sie den Abschluss interpretiert und ausführt. Der Leistungsunterschied zwischen ihnen liegt jedoch zwischen 3 % und 5 % (dies sind die von Google erhaltenen Daten, die möglicherweise nicht sehr genau sind).

Allerdings sind die Vorteile des Verschlusses auf jeden Fall großartig. Verwenden Sie mehr Schließungen und zustandslose Programmierung, um Fehler von uns fernzuhalten.

Wenn Sie Abschlüsse verstehen, können Sie die meisten Js-Klassenbibliotheken des FP-Paradigmas und die dahinter verborgenen Designideen verstehen. Natürlich reicht die Schließung nicht aus. Sie müssen sich auch mit Konzepten wie FP, Staatenlosigkeit und Lambda-Kalkül einer Gehirnwäsche unterziehen.

Ich hoffe, dass Sie nach Abschluss dieses Artikels ein Verständnis für js-Verschlüsse haben.

Verwandte Empfehlungen:

Eine einfache Erklärung von Abschlüssen in JS

Wie man Abschlüsse und Klassen in JS versteht

Ein einfaches Verständnis von js-Verschlüssen

Das obige ist der detaillierte Inhalt vonWas sind Verschlüsse in Javascript?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!