Analyse de la déclaration de fonction js et de l'expression de fonction

Cet article présente principalement l'analyse des déclarations de fonction et des expressions de fonction en js. Il a une certaine valeur de référence. Maintenant, je le partage avec vous. Les amis dans le besoin peuvent s'y référer

Définition

.

En JavaScript, nous avons les deux manières suivantes de définir des fonctions :

Déclaration de fonction

  function say(){
     console.log('函数声明');
  }

Expression de fonction

   var say = function(){
      console.log('函数表达式');
   }

2. Exemple d'analyse

Dans le développement normal, ils présentent des différences subtiles. Jetons un coup d'œil à l'exemple suivant :

    say();
    var say = function(){
          console.log('函数表达式');
    }
    say();
    function say(){
     console.log('函数声明');
    }
    say();

Vous pouvez d'abord y penser dans votre. mind Réfléchissez à la réponse. Le résultat de l'exécution est :

函数声明
函数表达式
函数表达式

Analysons ce résultat :

1 Lorsque la fonction say est appelée pour la première fois, la fonction n'a pas été définie. , alors pourquoi qu'en est-il de l'impression de la valeur de la « déclaration de fonction » ? La raison en est qu'il existe un mécanisme dans l'interpréteur

javascript par lequel les déclarations de variables sont promues, ce qui signifie que les déclarations de fonctions seront promues au début de la portée, même si le code est écrit Même ceux qui sont à l'arrière seront quand même promus à l'avant.
La fonction créée avec une expression de fonction est affectée au moment de l'exécution et ne peut pas être appelée tant que l'affectation de l'expression n'est pas terminée

Par conséquent, même si la fonction n'a pas été définie, la déclaration de fonction a été promue. Au début, le code ci-dessus est équivalent à :

    var say; //变量被提升，此时的值为undefined
    say();// 函数被提升，输出“函数声明”
    var say = function(){
          console.log('函数表达式');
    }
    say();
    function say(){
     console.log('函数声明');
    }
    say();

De la comparaison des deux suivants, on comprend mieux la notion de « promotion de déclaration de fonction » :
1.

var say;
console.log(say);
say();
function say(){
   console.log('函数声明');
}

输出：
f say(){
   console.log('函数声明');
}
函数声明

2.

var say;
console.log(say);
say();
var say = function(){
   console.log('函数表达式');
}

输出：
undefined
Uncaught TypeError: say is not a function
    at <anonymous>:3:1

2. Lorsque la fonction say est appelée pour la deuxième fois, on peut simplement comprendre que le 函数表达式 à ce moment couvre le 函数声明, donc le ' L'expression de fonction' est affichée. Cependant, lorsque la fonction par exemple est appelée pour la troisième fois, l'expression de fonction est toujours imprimée ? ? Pourquoi le 函数声明 suivant ne couvre-t-il pas le 函数表达式 précédent ? En fait, en raison de la promotion des déclarations de fonction au moment de l'exécution, l'ordre d'exécution réel est similaire à celui-ci :

function say() {
    console.log('函数声明');
}//因为函数声明提升，所以在最前面运行了
say();
var say = function() {
    console.log('函数表达式');
}
say();
say();

3Résumé

1. La déclaration de fonction est effectuée pendant l'analyse JS. Les fonctions sont hissées afin qu'elles puissent être appelées dans la même portée, quel que soit l'endroit où la fonction est déclarée.
2. La valeur de l'expression de fonction est déterminée lorsque JS est en cours d'exécution, et la fonction ne peut être appelée qu'une fois l'affectation de l'expression terminée.

Ce qui précède représente l'intégralité du contenu de cet article, je l'espère. sera utile à l'apprentissage de chacun, veuillez faire attention au site Web PHP chinois pour plus de contenu connexe !

Recommandations associées :

Comment convertir un pseudo-tableau en tableau via js

Comment utiliser JS pour trouver la méthode de différence de tableau

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!