En fait, la personne qui pose la question pense que la troisième façon d'écrire est étrange et semble inutile, car il ne comprend pas l'usage correct de cette façon d'écrire. Le deuxième exemple est plus intuitif

Pour faire simple, la première et la troisième sont toutes deux des expressions de fonction, et la seconde est une déclaration de fonction. La troisième est une expression de fonction plus spéciale avec des capacités spéciales.

Pour expliquer ce problème, nous devons comprendre « Quoi, Comment, Pourquoi ».

Donc, la principale différence entre le premier et le deuxième est que le timing de leurs déclarations est incohérent. Les expressions de fonction n'attribueront des valeurs aux variables que lorsque le code est exécuté sur cette instruction, tandis que les déclarations de fonction seront attribuées lors de la saisie du courant. contexte d'exécution de la fonction. Attribuez une valeur à l'avance.

Exemple intuitif

console.log(foo); // undefined

var foo = function(){};
 
console.log(foo); // function(){}


console.log(bar); // function(){}

function bar() {}

console.log(bar); // function(){}

Pour le troisième type, l'exemple intuitif est le suivant

console.log(foo); // undefined

var foo = function bar(){
    console.log(bar); // function(){...}
    console.log(foo); // undefined
};
 
console.log(foo); // function(){}
console.log(bar); // undefined

Vous pouvez donc voir la différence. L'identifiant de fonction écrit de cette manière est différent de la déclaration de fonction. Il est accessible à l'intérieur de la fonction, mais n'est pas accessible en dehors de la fonction. Nous le voyons donc écrit comme ceci à de nombreux endroits. Un avantage est que lorsqu'elle s'appelle lors de l'utilisation de la récursivité, la fonction a un nom, qui est plus intuitif

Pourquoi est-ce ?

Lorsque le navigateur analyse, il paie en fait l'identifiant après l'expression à l'objet fonction actuel, donc dans l'exemple ci-dessus

foo.name; // bar

Dans le contexte d'exécution au sein de la fonction, l'objet fonction actuel est dans la portée, il peut donc être appelé en interne

Ci-dessus

Ajoutez une explication de la troisième définition : elle est elle-même un 函数表达式,并不是函数定义语句L'expression de fonction peut avoir un nom de fonction, mais ce nom de fonction ne peut être utilisé qu'à l'intérieur de l'expression de fonction.Reportez-vous au Guide faisant autorité Javascript 8.1 Définition de la fonction Cette section :

Il existe de nombreuses façons de définir des fonctions dans les fonctions JavaScript MDN :

• Déclaration de fonction (instruction de fonction)

• expression de fonction

• Déclaration du générateur de fonctions (instruction de fonction*)

• Expression du générateur de fonctions (expression de fonction*)

• Expression de la fonction flèche (=>)

• Constructeur de fonctions

• Constructeur de fonction générateur

Pour la question de l'affiche originale, nous parlons uniquement de déclarations de fonctions et d'expressions de fonctions.

1) Déclaration de fonction

function name([param[, param[, ... param]]]) { 
    statements 
}

2) Expression de fonction

let function_expression = function [name]([param1[, param2[, ..., paramN]]]) {
   statements
};

name est facultatif Lorsque le nom de la fonction name est omis, la fonction devient une fonction anonyme.

Voyant cela, il n'est pas nécessaire de continuer à expliquer pourquoi il existe une troisième façon d'écrire, sinon ce serait vraiment déroutant, mais ici je dois parler de la différence entre la déclaration de fonction et l'expression de fonction, qui se reflète principalement dans le question de promotion variable :

JavaScript ne récupère que les déclarations, pas les initialisations. Il y a une promotion de variable sous la déclaration de fonction, mais pas sous l'expression de fonction. Par conséquent, l'expression de fonction appelle d'abord la fonction puis déclare la fonction et une erreur sera signalée.

Premierfoo => 没名字的function
第三个foo => 有名字的function

Mais deux function的执行内容是一样的的，都把这个函数赋值给fooobjets d'initialisation variable

Quant à la seconde, déclarez simplement une fonction normalement puis appelez la fonction

Le troisième type est l'opération d'affectation ! Attribuez une fonction à foo ! Si vous utilisez foo auparavant, cela revient à utiliser une variable non définie à l'avance ! Si vous console.log(foo) après le morceau de code que vous avez écrit pour imprimer la fonction entière, l'ajout d'un () appellera naturellement cette fonction !
N'oubliez pas que le signe égal unique est toujours une opération d'affectation en js, et que le côté droit du signe égal est le contenu de l'affectation ! N'y pensez pas trop ! Même si vous écrivez 100 fonctions supplémentaires après le signe égal, ce ne sera tout au plus qu'une affectation !