Eigenschaften von JavaScript-Funktionsausdrücken und Verständnis der Rekursion (mit Beispielen)

In diesem Artikel geht es um die Eigenschaften von JavaScript-Funktionsausdrücken (mit Beispielen). Ich hoffe, dass er für Freunde hilfreich ist.

Funktionsausdrücke sind eine leistungsstarke, aber verwirrende Funktion von JavaScript.

Es gibt zwei Möglichkeiten, Funktionen zu definieren: eine ist die Funktionsdeklaration und die andere ist der Funktionsausdruck.

Die Syntax der Funktionsdeklaration ist wie folgt.

function functionName(arg0, arg1, arg2) {
    //函数体
}

Syntax: Zuerst das Funktionsschlüsselwort, dann der Name der Funktion. So wird der Funktionsname angegeben.

Firefox, Safari, Chrome und Opera definieren alle ein nicht standardmäßiges Namensattribut für Funktionen, über das auf den für die Funktion angegebenen Namen zugegriffen werden kann.
Der Wert dieses Attributs entspricht immer dem Bezeichner, der dem Funktionsschlüsselwort folgt.

//只在Firefox、Safari、Chrome和Opera有效
function functionName(arg0, arg1, arg2) {
}
console.log(functionName.name); // "functionName"

Was die Funktionsdeklaration betrifft, ist eine ihrer wichtigen Funktionen das Hochziehen der Funktionsdeklaration, was bedeutet, dass die Funktionsdeklaration vor der Ausführung des Codes gelesen wird. Dies bedeutet, dass die Funktionsdeklaration nach der Anweisung platziert werden kann, die sie aufruft.

sayName(); // "Shaw"
function sayName(){
    console.log("Shaw");
}

Dieses Beispiel gibt keinen Fehler aus, da die Funktionsdeklaration gelesen wird, bevor der Code ausgeführt wird

Die zweite Möglichkeit, eine Funktion zu erstellen, ist die Verwendung von Funktionsausdruck.

Funktionsausdrücke haben verschiedene Syntaxformen.
Das Folgende ist die häufigste Form.

var functionName =  function(arg0, arg1, arg2) {
    //functionBody
};

Dieses Formular sieht aus wie eine reguläre Variablenzuweisungsanweisung, das heißt, eine Funktion zu erstellen und sie der Variablen functionName zuzuweisen.

Die in diesem Fall erstellte Funktion wird anonyme Funktion genannt, da nach dem Funktionsschlüsselwort kein Bezeichner steht.
Anonyme Funktionen werden auch Lambda-Funktionen genannt. Das Namensattribut der anonymen Funktion ist ein Nullzeichen.

Funktionsausdrücken muss wie anderen Ausdrücken vor der Verwendung ein Wert zugewiesen werden.

sayHi(); // error : sayHi is not a function
var sayHi = function(){
    console.log("Hi");
}
// var sayHi //此时sayHi是undefined
// sayHi() // error : sayHi is not a function
// sayHi = function() { console.log("Hi");}

Der Schlüssel zum Verständnis des Funktionshebens liegt darin, den Unterschied zwischen Funktionsdeklarationen und Funktionsausdrücken zu verstehen.

Sie können eine Funktion erstellen und einer Variablen zuweisen, und Sie können die Funktion auch als Wert anderer Funktionen zurückgeben.

function createComparisonFunction(propertyName) {
    return function(object1, object2) {
        var value1 = object1[propertyName];
        var value2 = object2[propertyName];
        if(value1 < value2) {
            return -1
        }else if(value1 > value2) {
            return 1;
        } else {
            return 0;
        }
    }
}

createComparisonFunction() gibt eine anonyme Funktion zurück.
Die zurückgegebene Funktion kann einer Variablen zugewiesen oder auf andere Weise aufgerufen werden.
Innerhalb der Funktion createComparisonFunction() ist es jedoch anonym.
Anonyme Funktionen können immer dann verwendet werden, wenn Funktionen als Werte verwendet werden.
Dies ist jedoch nicht die einzige Verwendung anonymer Funktionen.

Rekursion

Eine rekursive Funktion entsteht, wenn eine Funktion sich selbst über den Funktionsnamen aufruft.

function factorial(num) {
    if(num <= 1) {
        return 1;
    } else {
        return num * factorial(num-1);
    }
}
factorial(4); // 4*3*2*1 = 24

//4* factorial(3) => 4*3*factorial(2) => 4*3*2*factorial(1) => 4*3*2*1 => 24

Dies ist eine klassische rekursive Fakultätsfunktion. Obwohl diese Funktion auf den ersten Blick gut aussieht, kann der folgende Code zu einem Fehler führen.

function factorial(num) {
    if(num <= 1) {
        return 1;
    } else {
        return num * factorial(num-1);
    }
}
var anotherFactorial = factorial;
factorial = null;
//注意这里，其实函数factorial指向一个空对象。
console.log(anotherFactorial(4));  //Error: anotherFactorial is not a function

Der obige Code speichert zunächst die Funktion „factorial()“ in der Variablen anotherFactory und setzt dann die Variable „factorial“ auf null. Dadurch gibt es nur einen Verweis auf die ursprüngliche Funktion.
Aber wenn anotherFactory() als nächstes aufgerufen wird, muss Factorial() ausgeführt werden, und Factorial ist keine Funktion mehr, sodass ein Fehler auftritt.

Google Chrome hat den obigen Code getestet und er hat nicht funktioniert. Es wird empfohlen, diesen Teil nicht im Detail zu verstehen.
In diesem Fall kann die Verwendung von arguments.callee das Problem lösen.

arguments.callee ist ein Zeiger auf die ausgeführte Funktion und kann daher zum Implementieren rekursiver Aufrufe der Funktion verwendet werden.

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

„return num * arguments.callee(num-1);“ Durch die Verwendung von arguments.callee anstelle des Funktionsnamens können Sie sicherstellen, dass es kein Problem gibt, egal wie Sie die Funktion aufrufen.
Daher ist es beim Schreiben rekursiver Funktionen immer sicherer, arguments.callee zu verwenden als Funktionsnamen.

Im strikten Modus kann jedoch nicht über Skripts auf arguments.callee zugegriffen werden, und der Zugriff auf diese Eigenschaft führt zu einem Fehler.

Wir können jedoch benannte Funktionsausdrücke verwenden, um das gleiche Ergebnis zu erzielen.

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

//factorial 指向了函数f

var anotherFactorial = factorial;
//anotherFactorial 指向了函数f

factorial = null;
//factorial 指向了一个空对象。

anotherFactorial(4); //24
////anotherFactorial 指向了函数f, 所以还可以正常调用。

Der obige Code erstellt einen benannten Funktionsausdruck mit dem Namen f() und weist ihn dann der Variablen Fakultät zu.
Auch wenn die Funktion einer anderen Variablen zugewiesen wird, ist der Funktionsname f weiterhin gültig, sodass der rekursive Aufruf weiterhin korrekt abgeschlossen werden kann.
Dieser Ansatz funktioniert sowohl im strengen als auch im nicht strengen Modus.

Das obige ist der detaillierte Inhalt vonEigenschaften von JavaScript-Funktionsausdrücken und Verständnis der Rekursion (mit Beispielen). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!