JavaScript-Funktionsausdrücke

Funktion definieren: a. Funktionsdeklaration Funktionsname (Name, Alter) {}———— Funktionsdeklaration                                     >

Rekursion

Abschluss

Der Umfang von Variablen besteht aus nichts anderem als zwei Typen: globale Variablen und lokale Variablen.

Das Besondere an der Javascript-Sprache ist, dass globale Variablen direkt innerhalb der Funktion gelesen werden können.

Wie lese ich lokale Variablen von außen?

Das heißt, eine Funktion innerhalb der Funktion zu definieren. Indem Sie eine interne Funktion als Rückgabewert verwenden, können Sie ihre internen Variablen von außen lesen

Ein Abschluss ist eine Funktion, die die internen Variablen anderer Funktionen lesen kann.

Da in der Javascript-Sprache nur Unterfunktionen innerhalb der Funktion lokale Variablen lesen können, können Abschlüsse einfach als „innerhalb einer Funktion definierte Funktionen“ verstanden werden.

Im Wesentlichen ist der Abschluss also eine Brücke, die das Innere der Funktion mit der Außenseite der Funktion verbindet.

Es hat zwei Hauptzwecke: Zum einen werden die Variablen innerhalb der Funktion gelesen, und zum anderen werden die Werte dieser Variablen im Speicher gehalten.

Hinweise zur Verwendung von Abschlüssen

1) Da Abschlüsse dazu führen, dass die Variablen in der Funktion im Speicher gespeichert werden, ist der Speicherverbrauch sehr groß und kann daher nicht gespeichert werden missbraucht Schließung, andernfalls führt es zu Leistungsproblemen auf der Webseite und kann zu Speicherverlusten im IE führen. Die Lösung besteht darin, alle nicht verwendeten lokalen Variablen zu löschen, bevor die Funktion beendet wird.

2) Der Abschluss ändert den Wert der Variablen innerhalb der übergeordneten Funktion außerhalb der übergeordneten Funktion. Wenn Sie daher die übergeordnete Funktion als Objekt, den Abschluss als öffentliche Methode und die internen Variablen als privaten Wert verwenden, müssen Sie darauf achten, den Wert der Variablen innerhalb der übergeordneten Funktion nicht zu ändern.

Schließung ist ein relativ abstraktes Konzept, insbesondere für Js-Neulinge. Die Erklärung im Buch ist wirklich unklar, und das gilt auch für mich.

Aber das ist es Auch ein unvermeidlicher Link zur Verbesserung der js-Fähigkeiten ist eine Frage, die in fast jedem Interview gestellt werden muss, denn bei der Beantwortung kommt es auf die Tiefe Ihrer Antwort, das Verständnis der Terminologie und die Beschreibung der Funktionsweise des internen js-Interpreters an kann Ihr tatsächliches js-Niveau anzeigen. Auch wenn Sie nicht richtig antworten, kann es dem Prüfer ermöglichen, Ihr Niveau zu beurteilen. Lassen Sie mich zunächst über mein Verständnis von Abschlüssen in js sprechen Funktion, die viele Sprachen haben. In js umfasst der Abschluss hauptsächlich mehrere andere Funktionen von js: Bereichskette, Müll-(Speicher-)Recyclingmechanismus, Funktionsverschachtelung usw.

Bevor Sie Abschlüsse verstehen, ist es am besten, sie zuerst zu verstehen Verstehen Sie die Bedeutung der Bereichskette. Einfach ausgedrückt ist die Bereichskette ein Index, der erstellt wird, wenn eine Funktion verwendet wird, um den Wert einer verwendeten Variablen zu finden. Ihre interne Regel besteht darin, die lokalen Variablen der Funktion selbst an die erste Stelle zu setzen Die eigene übergeordnete Funktion wird als zweites verwendet, die Variablen werden in der übergeordneten Funktion weiter hinten platziert und so weiter bis zum globalen Objekt. Wenn der Wert einer Variablen in der Funktion abgefragt werden muss, wechselt der js-Interpreter zur Bereichskette Wenn die entsprechende Variable nicht gefunden wird, wird die Suche fortgesetzt. Sobald die Variable gefunden wurde, wird sie nicht fortgesetzt Der Interpreter gibt undefiniert zurück. Nachdem wir nun die Bereichskette verstanden haben, werfen wir einen Blick auf den Speicherrecyclingmechanismus von js. Im Allgemeinen werden die darin definierten Variablen in Speicherbereiche unterteilt Um sie zur Verwendung in nachfolgenden Anweisungen zu speichern, gelten diese Variablen als nutzlos. Der entsprechende Speicherplatz wurde zurückgewonnen. Bei der nächsten Ausführung dieser Funktion kehren alle Variablen in ihren ursprünglichen Zustand zurück Wenn jedoch eine andere Funktion in dieser Funktion verschachtelt ist, ist es möglich, dass diese Funktion von außen aufgerufen wird. Wenn diese interne Funktion einige Variablen der externen Funktion verwendet, führt dies zu Problemen Wenn die interne Funktion direkt nach der Rückkehr der externen Funktion aufgerufen wird, kann die interne Funktion den Wert der Variablen in der von ihr benötigten externen Funktion nicht lesen. Wenn der JS-Interpreter daher auf eine Funktionsdefinition stößt, kombiniert er automatisch die Funktion und die Die möglicherweise verwendeten Variablen (einschließlich lokaler Variablen und Variablen der übergeordneten und Vorgängerfunktionen) werden zusammen gespeichert. Das heißt, diese Variablen werden vom Speicherkollektor nur dann wiederverwendet, wenn die interne Funktion aktiviert ist kann nicht aufgerufen werden (z. B. wird gelöscht oder es gibt keinen Zeiger), wird der Abschluss zerstört und es werden keine durch den Abschluss referenzierten Variablen recycelt, wenn das nächste Speicherrecycling gestartet wird.

In anderen Fällen Mit Schließungen können verschachtelte Funktionsstrukturen funktionieren, was auch unseren Erwartungen entspricht. Dann haben Schließungen auch einige Funktionen, die es Programmierern oft schwer machen, sie zu verstehen .

这段代码中,程序员希望foo函数中的变量i被内部循环的函数使用,并且能分别获得他们的索引,而实际上,只能获得该变量最后保留的值,也就是说.闭包中所记录的自由变量,只是对这个变量的一个引用,而非变量的值,当这个变量被改变了,闭包里获取到的变量值,也会被改变.

解决的方法之一,是让内部函数在循环创建的时候立即执行,并且捕捉当前的索引值,然后记录在自己的一个本地变量里.然后利用返回函数的方法,重写内部函数,让下一次调用的时候,返回本地变量的值,改进后的代码

var result=[];function foo(){
    var i= 0;
    for (;i<3;i=i+1){
        result[i]=(function(j){
            return function(){
                alert(j);
            };
        })(i);
    }
};
foo();
result[0](); // 0
result[1](); // 1
result[2](); // 2

 

在这里我再解释一下.这里用到了另外2个技术,立即调用的匿名函数和返回函数.也是初学者比较难以理解的部分.

私有变量

任何在函数中定义的变量，都可以是私有变量。

把有权访问私有变量和私有函数的方法称为特权方法，a）在构造函数中定义特权方法

b）在私有作用域中定义变量或函数，私有变量和函数由实例共享

模块模式——为单例创建私有变量和特权方法。单例，指只有一个实例的对象

使用一个返回对象的匿名函数，函数内部首先定义私有变量和函数，将一个对象字面量作为函数的值返回，返回的 对象字面量只包含公开的属性和方法。