Caractéristiques des expressions de fonctions JavaScript et compréhension de la récursivité (avec exemples)

Ce que cet article vous apporte concerne les caractéristiques des expressions de fonction JavaScript et la compréhension de la récursivité (avec des exemples). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Les expressions de fonction sont une fonctionnalité puissante mais déroutante de JavaScript.

Il existe deux façons de définir des fonctions : l'une est la déclaration de fonction et l'autre est l'expression de fonction.

La syntaxe de la déclaration de fonction est la suivante.

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

Syntaxe : D'abord le mot-clé de la fonction, puis le nom de la fonction. C'est ainsi que le nom de la fonction est spécifié.

Firefox, Safari, Chrome et Opera définissent tous un attribut de nom non standard pour les fonctions, via lequel le nom spécifié pour la fonction est accessible.
La valeur de cet attribut est toujours égale à l'identifiant suivant le mot-clé fonction.

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

Concernant la déclaration de fonction, l'une de ses fonctionnalités importantes est le levage de la déclaration de fonction, ce qui signifie que la déclaration de fonction est lue avant d'exécuter le code. Cela signifie que la déclaration de fonction peut être placée après l'instruction qui l'appelle.

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

Cet exemple ne générera pas d'erreur car la déclaration de fonction sera lue avant l'exécution du code

La deuxième façon de créer une fonction utilise des expressions de fonction.

Les expressions de fonction ont plusieurs formes syntaxiques différentes.
Ce qui suit est la forme la plus courante.

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

Ce formulaire ressemble à une instruction d'affectation de variable classique, c'est-à-dire créer une fonction et l'attribuer à la variable functionName.

La fonction créée dans ce cas est appelée fonction anonyme , car il n'y a pas d'identifiant après le mot-clé function.
Les fonctions anonymes sont également appelées fonctions lambda. L'attribut name de la fonction anonyme est un caractère nul.

Les expressions de fonction, comme les autres expressions, doivent se voir attribuer une valeur avant utilisation.

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");}

La clé pour comprendre le levage de fonctions est de comprendre la différence entre les déclarations de fonction et les expressions de fonction.

Vous pouvez créer une fonction et l'attribuer à une variable, et vous pouvez également renvoyer la fonction comme valeur d'autres fonctions.

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() renvoie une fonction anonyme.
La fonction renvoyée peut être affectée à une variable ou appelée d'une autre manière.
Cependant, à l’intérieur de la fonction createComparisonFunction(), elle est anonyme.
Les fonctions anonymes peuvent être utilisées chaque fois que des fonctions sont utilisées comme valeurs.
Cependant, ce n'est pas la seule utilisation des fonctions anonymes.

Récursion

Une fonction récursive est formée lorsqu'une fonction s'appelle via le nom de la fonction.

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

Il s'agit d'une fonction factorielle récursive classique. Bien que cette fonction semble correcte à première vue, le code suivant peut provoquer une erreur.

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

Le code ci-dessus enregistre d'abord la fonction factorial() dans la variable anotherFactory, puis définit la variable factorielle sur null. Par conséquent, il n'y a qu'une seule référence à la fonction d'origine.
Mais lorsque anotherFactory() est appelé ensuite, factorial() doit être exécuté et factorial n'est plus une fonction, donc une erreur se produira.

Google Chrome a testé le code ci-dessus et cela n'a pas fonctionné. Il est recommandé de ne pas comprendre cette partie en profondeur.
Dans ce cas, utiliser arguments.callee peut résoudre le problème.

arguments.callee est un pointeur vers la fonction en cours d'exécution, il peut donc être utilisé pour implémenter des appels récursifs à la fonction.

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

"return num * arguments.callee(num-1);" En utilisant arguments.callee au lieu du nom de la fonction, vous pouvez vous assurer qu'il n'y aura aucun problème, quelle que soit la façon dont vous appelez la fonction. .
Par conséquent, lors de l'écriture de fonctions récursives, il est toujours plus sûr d'utiliser arguments.callee que d'utiliser des noms de fonction.

Mais en mode strict, arguments.callee n'est pas accessible via des scripts, et l'accès à cette propriété provoquera une erreur.

Cependant, nous pouvons utiliser des expressions de fonctions nommées pour obtenir le même résultat.

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, 所以还可以正常调用。

Le code ci-dessus crée une expression de fonction nommée f(), puis l'assigne à la variable factorielle.
Même si la fonction est affectée à une autre variable, le nom de la fonction f est toujours valide, donc l'appel récursif peut toujours être effectué correctement.
Cette approche fonctionne à la fois en mode strict et non strict.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!