Eine kurze Analyse der Javascript-Funktionsausdrücke_Javascript-Fähigkeiten

Beginnen Sie mit dem Erlernen von Javascript-Funktionsausdrücken und lesen Sie Folgendes sorgfältig durch.

1. In der allgemeinen Form der Funktionserstellung wird die Funktionsdeklaration vor der Ausführung des Codes gelesen, sodass die Funktionsdeklaration unter den Funktionsaufruf geschrieben werden kann:

 sayHi();
 function sayHi(){
     alert("Hi!");
}

2. Verwenden Sie Funktionsausdrücke, um Funktionen zu erstellen, denen vor dem Aufruf ein Wert zugewiesen werden muss:

 sayHi(); //错误！！函数不存在
 var sayHi=function(){
     alert("Hi!");
}

3. Rekursion

Allgemeine Rekursion

function factorial(num){
        if (num <= 1){
          return 1;
        } else {
          return num * factorial(num-1);
        }
      }

arguments.callee ist ein Zeiger auf die ausgeführte Funktion, der zum Implementieren einer Rekursion verwendet werden kann:

function factorial(num){
        if (num <= 1){
          return 1;
        } else {
          return num * arguments.callee(num-1);
        }
      }

4. Abschluss ( Abschluss bezieht sich auf eine Funktion, die auf Variablen in einem anderen Bereich zugreifen kann ).
Eine übliche Methode zum Erstellen von Abschlüssen besteht darin, eine Funktion innerhalb einer anderen Funktion zu erstellen. Wenn eine Funktion ausgeführt wird, werden eine Ausführungsumgebung und eine entsprechende Bereichskette erstellt. Ein Abschluss kann nur den letzten Wert einer beliebigen Variablen in der enthaltenden Funktion annehmen:

function createFunctions(){
        var result = new Array();
        
        for (var i=0; i < 10; i++){
          result[i] = function(){
            return i;
          };
        }
        
        return result;
      }
      
      var funcs = createFunctions();
      
      //every function outputs 10
      for (var i=0; i < funcs.length; i++){
        document.write(funcs[i]() + "<br />");
      }

Der obige Code gibt alle 10 aus. Dies liegt daran, dass jede funcs-Funktion das aktive Objekt createFunctions() speichert (das eine Funktion, ein Objekt und einen Referenztyp ist) und das aktive Objekt createFunctions() eine Variable i hat, sodass jede Funktion diese hat Variable i, und wenn die Funktion createFunctions() das Ergebnis zurückgibt, ist i zu 10 geworden. Jeder Wert des funcs-Arrays ist also 10.

Kann wie folgt umgewandelt werden:

function createFunctions(){
        var result = new Array();
        
        for (var i=0; i < 10; i++){
          result[i] = function(num){
            return function(){
              return num;
            };
          }(i);
        }
        
        return result;
      }

Wenn jede anonyme Funktion aufgerufen wird, wird der aktuelle Wert von i an num übergeben, und innerhalb der anonymen Funktion wird ein Abschluss von num erstellt und zurückgegeben. Auf diese Weise verfügt jede Funktion, die ein Array zurückgibt, über eine eigene Kopie der Num-Variablen. (Dieser Absatz ist nicht klar erklärt, die Leser können es selbst herausfinden. Wenn es eine bessere Möglichkeit gibt, ihn zu beschreiben, kommentieren Sie bitte unter dem Artikel, danke)

5. dieses Objekt

• In globalen Funktionen entspricht dies dem Fenster.
  
• Wenn eine Funktion als Methode aufgerufen wird, entspricht dies diesem Objekt.
  
• Wenn jede Funktion aufgerufen wird, erhält diese Funktion automatisch zwei spezielle Variablen: this und arguments. Wenn die interne Funktion diese beiden Variablen durchsucht, sucht sie nur bis zum aktiven Objekt.
  

6. Imitieren Sie den Bereich auf Blockebene (privater Bereich)
Wie folgt:

function outputNumbers(count){
        for (var i=0; i < count; i++){
          alert(i);
        }
      
        alert(i);  //count
      }

      outputNumbers(5);

In Sprachen wie Java wird die Variable i in for bei Verwendung zerstört. In JavaScript wird beim Aufruf von „outputNumbers“ ein aktives Objekt generiert, und dieses i gehört zu diesem aktiven Objekt. Da es also definiert ist, kann überall innerhalb der Funktion darauf zugegriffen werden und es wird innerhalb des aktiven Objekts gemeinsam genutzt.

Syntax für anonyme Funktionen (privaten Bereich erstellen):

(function(){
 //这里是块级作用域
})();

Die Funktionsdeklaration wird in Klammern gesetzt, um anzuzeigen, dass es sich um einen Ausdruck handelt, und durch das Hinzufügen von Klammern kann sie sofort aufgerufen werden.

Wenn Sie einige Variablen vorübergehend benötigen, können Sie den privaten Bereich verwenden:

function outputNumbers(count){
      
        (function () {
          for (var i=0; i < count; i++){
            alert(i);
          }
        })();
        
        alert(i);  //causes an error
      }

Im obigen Code ist i privat und es wird ein Fehler gemeldet, wenn außerhalb der anonymen Funktion (private Domäne) auf i zugegriffen wird, obwohl sich die Warnung immer noch innerhalb des aktiven Objekts befindet.

7. Private Variablen
Die in der Funktion definierten Parameter, lokalen Variablen und anderen Funktionen sind alle private Variablen der Funktion. Zum Beispiel:

function add(num1,num2){
  var sum = num1 + num2;
  return sum; 
}

Es gibt 3 private Variablen: num1, num2, sum. Auf sie kann innerhalb der Funktion zugegriffen werden, jedoch nicht außerhalb.

Privilegierte Methoden können auf private Variablen zugreifen: Einfach ausgedrückt, verwenden Sie einen Ausdruck, um ihm einen Abschluss zu geben, und greifen Sie auf andere Funktionen innerhalb des Abschlusses zu:

 function Person(name){

        var a=0;
      
        this.getName = function(){
          return name + a;
        };
      
        this.setName = function (value) {
          name = value;
        };
      }

This.getName und this.setName sind Ausdrucksmethoden. Nach dem Erstellen einer Personeninstanz kann auf den Namen und ein Attribut nur über getName oder setName zugegriffen werden.

Das Obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, er wird für das Studium aller hilfreich sein.