Une brève analyse des déclarations de fonctions et des expressions de fonctions - déclaration des déclarations de fonctions à l'avance_Connaissances de base

Les deux premiers jours de la fête de classe, à part manger, boire, s'amuser, dormir et parler, c'était vraiment joyeux. Ce n'est vraiment pas aussi bien que de s'amuser seul que de s'amuser ensemble.

PS : Ceux qui ont obtenu leur diplôme ou sont sur le point de l'obtenir, réunissez-vous simplement si vous avez le temps. Après l'obtention de votre diplôme, vous aurez trop peu de temps pour vous réunir.

Maintenant, j'ai un peu de temps pour examiner certaines choses et résumer certaines choses, et parce que j'ai regardé la partie fonction de JavaScript pièce par pièce il y a quelque temps, j'ai pris le temps de résumer les parties pertinentes de la fonction. , certaines parties sont les miennes. Je comprends, s'il y a un problème avec ma compréhension, n'hésitez pas à le signaler.

Dans cette section, je parlerai à l'avance de la déclaration des déclarations de fonctions en fonction de ma propre compréhension.

Remarque : à certains endroits, cela est également appelé promotion de déclaration de fonction. La traduction est différente, mais le sens est le même, à condition que tout le monde le comprenne. Vive la compréhension !

Avant de parler à l'avance de la déclaration de fonction, il est nécessaire d'introduire plusieurs méthodes de définition de fonction, qui devraient être familières à la plupart des amis. Si vous savez quelque chose ou si vous ne voulez pas le savoir, faites-le simplement rouler. Si vous ne le connaissez pas ou si vous souhaitez vous y familiariser, ralentissez simplement et commencez à marcher.

Comment définir des fonctions

Il existe trois manières principales de définir des fonctions :

1. Déclaration de fonction
2. Expression de fonction)
3.nouveau constructeur de fonction
Parmi elles, les méthodes de définition de fonction de déclaration de fonction et d'expression de fonction sont souvent utilisées. Ces deux méthodes présentent des différences et des connexions très subtiles, et l'utilisation de ces deux méthodes est également facile à confondre, donc cet article résume principalement ces deux méthodes pertinentes. Points de connaissance sur les méthodes de définition de fonctions. Bien entendu, le thème de cet article concerne toujours les fonctions à l'avance.

Format typique de déclaration de fonction :

function functionName(arg1, arg2, ...){
  <!-- function body -->
}

Expression de fonction

•Format typique d'expression de fonction :

var variable=function(arg1, arg2, ...){
      <!-- function body -->
}

Expression de fonction contenant le nom (crochets, nom de la fonction) :

var variable=function functionName(arg1, arg2, ...){
    <!-- function body -->
}

Les expressions de fonction portant des noms comme ceux ci-dessus peuvent être utilisées de manière récursive :

var variable=function functionName(x){
    if(x<=1)
      return 1;
    else
      return x*functionName(x);
}

Déclaration préalable

Déclaration var à l'avance

Tout le monde aurait dû entendre parler de la déclaration de fonction à l'avance. Je voudrais le réitérer ici car la déclaration à l'avance est une différence importante entre la déclaration de fonction et l'expression de fonction. Il est important pour nous de mieux comprendre ces deux méthodes de définition de fonction. .une signification importante.

Mais avant de parler à l'avance de la déclaration de fonction, il faut parler à l'avance de la déclaration var.

Donnez d'abord la conclusion avant l'instruction var :

Les variables sont définies dans le script ou la fonction dans lequel elles sont déclarées, et l'instruction de déclaration de variable sera avancée en haut du script ou de la fonction. Cependant, l'opération d'initialisation de la variable est toujours effectuée à l'emplacement de l'instruction var d'origine et la valeur de la variable n'est pas définie avant l'instruction de déclaration.

Trois points simples peuvent être résumés à partir de la conclusion ci-dessus :

1. La déclaration des variables sera avancée en haut de la fonction
2. Seule la déclaration est avancée, l'initialisation n'est pas avancée et l'initialisation est toujours effectuée à la position d'initialisation d'origine
; 3. La valeur de la variable avant la déclaration n'est pas définie.

Donnons un exemple :

var handsome='handsome';
function handsomeToUgly(){
  alert(handsome);
  var handsome='ugly';
  alert(handsome);
}
handsomeToUgly();

Le résultat correct est :
Sortie d'abord indéfinie, puis sortie moche.

La mauvaise sortie est :
D'abord, sortez beau, puis sortez moche.

Voici le rôle de la déclaration des variables à l'avance. La belle variable locale est définie dans tout le corps de la fonction.La belle variable dans le corps de la fonction est supprimée.Oh non, elle couvre la belle variable globale du même nom Parce que la variable est déclarée à l'avance, c'est-à-dire que var beau est. avancé à la fonction. En haut, voici à quoi cela ressemble :

var handsome='handsome';
function handsomeToUgly(){
  var handsome;
  alert(handsome);
  var handsome='ugly';
  alert(handsome);
}
handsomeToUgly();

Donc avant alert(handsome), il y a déjà une déclaration var beau, comme mentionné ci-dessus

La valeur de la variable avant déclaration est indéfinie
La première sortie n’est donc pas définie.

Et à cause de ce qui précède :

Seule la déclaration est avancée, l'initialisation n'est pas avancée et l'initialisation est toujours effectuée à la position d'initialisation d'origine
La deuxième sortie est donc moche.

Déclaration de fonction à l'avance
Dans les deux prochains chapitres, nous commencerons à parler à l'avance de la déclaration des déclarations de fonctions en conjonction avec la déclaration var.

Tout le monde devrait être familier avec la déclaration de fonction à l'avance. Laissez-moi vous donner un exemple très familier.

sayTruth();<!-- 函数声明 -->
function sayTruth(){
  alert('myvin is handsome.');
}

sayTruth();<!-- 函数表达式 -->
var sayTruth=function(){
  alert('myvin is handsome.');
}

小伙伴们都知道，对于函数声明的函数定义方法，即上面的第一种函数调用方法是正确的，可以输出myvin is handsome.的真理，因为函数调用语句可以放在函数声明之后。而对于函数表达式的函数定义方法，即上面的第二种函数调用的方法是不能输出myvin is handsome.的正确结果的。

结合上面的myvin is handsome.例子，函数声明提前的结论似乎很好理解，不就是在使用函数声明的函数定义方法的时候，函数调用可以放在任意位置嘛。对啊，你说的很对啊，小伙伴，我都不知道怎么反驳你了。那就容我再扯几句。

从小伙伴所说的

不就是在使用函数声明的函数定义方法的时候，函数调用可以放在任意位置嘛
可以引出一点：

函数声明提前的时候，函数声明和函数体均提前了。

而且：

函数声明是在预执行期执行的，就是说函数声明是在浏览器准备执行代码的时候执行的。因为函数声明在预执行期被执行，所以到了执行期，函数声明就不再执行（人家都执行过了自然就不再执行了）。

上面是一点。

函数表达式为什么不能声明提前
我们再说一点：为什么函数表达式不能像函数声明那样进行函数声明提前呢？

辛亏我知道一点儿，否则真不知道我该怎么回答呢？

咳咳，按照我的理解给小伙伴们解释一下下：

我们上面说了var的声明提前，注意我上面提过的：

只是声明被提前，初始化不提前，初始化还在原来初始化的位置进行初始化

Ok，我们把函数表达式摆在这看看：

var variable=function(arg1, arg2, ...){
          <!-- function body -->
}

函数表达式就是把函数定义的方式写成表达式的方式（貌似是白说，但是这对于解释和理解为毛函数表达式不能函数声明提前具有良好的疗效），就是把一个函数对象赋值给一个变量，所以我们把函数表达式写成这个样子：

var varible=5看到这，也许小伙伴们会明白了，一个是把一个值赋值给一个变量，一个是把函数对象赋值给一个变量，所以对于函数表达式，变量赋值是不会提前的，即function(arg1, arg2, ...){bb673d5c66f2af4526aea043e376eb75}是不会提前的，所以函数定义并没有被执行，所以函数表达式不能像函数声明那样进行函数声明提前。

函数声明提前的实例分析

还是那句话，还是例子来的实在：

sayTruth();
if(1){
  function sayTruth(){alert('myvin is handsome')};
}
else{
  function sayTruth(){alert('myvin is ugly')};
}

在浏览器不抛出错误的情况下（请自行测试相应的浏览器是否有抛出错误的情况，为啥我不测试？我能说我懒么。。。），浏览器的输出结果是输出myvin is ugly（我不愿承认，但是事实就是这样啊啊啊啊，难道道出了人丑就该多读书？？？？？？）。

为什么呢？当然是声明提前了。因为函数声明提前，所以函数声明会在代码执行前进行解析，执行顺序是这样的，先解析function sayTruth(){alert('myvin is handsome')}，在解析function sayTruth(){alert('myvin is ugly')}，覆盖了前面的函数声明，当我们调用sayTruth()函数的时候，也就是到了代码执行期间，声明会被忽略，所以自然会输出myvin is ugly（好残酷的现实。。。）。忘了的可以看上面说过的：

函数声明是在预执行期执行的，就是说函数声明是在浏览器准备执行代码的时候执行的。因为函数声明在预执行期被执行，所以到了执行期，函数声明就不再执行了（人家都执行过了自然就不再执行了）。

小了个结

关于函数声明的函数提前（提升）就聊到这里先，希望我的理解和扯淡能够对有需要的小伙伴有所帮助。

当然，实践出真知。对事物的了解、认知和运用还是在于多看多用多总结，记得有句名言，是讲声明和实践的：“动起来，为新的声明喝彩。”。

以上这篇浅析函数声明和函数表达式——函数声明的声明提前就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。