javascript - La déclaration de fonction et la variable déclarée existent en même temps, quelles sont les règles de promotion?

Question

Nous savons que la déclaration de variables sera favorisée :

var a = 1;
//上面一行相当于下面这样：
var a;
a = 1；

Parallèlement, les déclarations de fonctions seront également favorisées :

foo();
function foo(){};
//上面两行相当于下面这样：
var foo;
foo = function (){};
foo()

Alors, lorsqu'il y a à la fois des déclarations de variables et de fonctions, qui arrivera au sommet ? Comment trier ? Par exemple :

var a = 1;
foo();
function foo(){};

Est-ce vrai ?

var a;
var foo;
a = 1；
foo = function(){};
foo();

Parce que j'ai vu cette phrase dans "JAVASCRIPT You Don't Know" et j'étais un peu confus :

Les déclarations de fonctions et les déclarations de variables seront promues. Mais un détail remarquable est que les fonctions sont promues en premier, puis les variables. Les déclarations de fonctions sont hissées avant les variables ordinaires.

Ça sera donc trié comme ceci :

var foo;
foo = function(){};
var a;
a = 1；
foo();

Retrouvez les règles de tri, merci !

Answer 1

Cette affirmation selon laquelle « l'amélioration d'abord » est en fait un malentendu. Ce n'est qu'une apparence superficielle. Les spécifications ne sont pas classées dans un ordre particulier (si vous êtes intéressé par l'implémentation du V8, vous pouvez lire ici).

var 的提升是声明跟赋值分开，function L'amélioration est toute l'amélioration, alors

var a = 1;
a();
function a(){};

Ça deviendra comme ça

var a;
function a(){};
a = 1;
a();

Il y a donc l'effet de la promotion de la fonction en premier.

Answer 2

Tout d'abord, on peut le diviser en 4 éléments de contenu

var a ;
a =1;
foo();
function foo();

On veut savoir à quoi ressemble le format de tri après promotion ?
La condition connue actuelle est que la déclaration de variable sera promue avant l'affectation de variable, nous pouvons donc mettre la déclaration de variable dans les deux premiers chiffres en premier, quel que soit son ordre interne pour le moment :

var a ;
function foo(){};
a=1;
foo();

Ensuite, déterminons respectivement l’ordre interne des modules de déclaration et d’affectation.
Afin de mener des expériences, nous avons étendu la fonction foo, donc l'ordre actuel est :

var a;
function foo(){console.log(a+1)};
a=1;
foo();

Ne vous inquiétez pas de la raison pour laquelle nous l'avons modifié ainsi. Continuons l'expérience. Nous le comprendrons au cours de l'expérience.
Afin de faciliter la compréhension, l'expérience a été menée en deux temps.
Premièrement : nous expérimentons le module de déclaration de variables.

var a=1;
console.log(foo);//若输出为function foo(){}则证明函数声明位于变量声明之前;若为undefined,说明相反。
foo();
function foo(){console.log(a+1)};

Ensuite : nous expérimentons le module d'affectation de variables.

var a=1;
foo();//若输出为undefined1，则证明foo()在a=1之前；若输出为2,则说明a=1在foo()之前。
function foo(){console.log(a+1)};

Faisons l'expérience :

var a=1;
console.log(foo);//若输出为function foo(){}则证明函数声明位于变量声明之前;若为undefined,说明相反。
foo();
function foo(){console.log(a+1)};

VM1099:2 function foo(){console.log(a+1)}
VM1099:4 2

Sur la base des résultats expérimentaux, notre résultat final de classement est :

function foo(){};
var a;
a=1;
foo();

Answer 3

var a = 1;
foo();
function foo(){};
提升之后
function foo(){};
var a;
a = 1;
foo();

给你举个更明显的例子
console.log(1, foo, typeof foo);
var foo = "变量";
console.log(2, foo, typeof foo);
function foo(){
    console.log("函数声明");
}
console.log(3, foo, typeof foo);
=》
function foo(){
    console.log("函数声明");
}
var foo;
console.log(1, foo, typeof foo);
foo = "变量";
console.log(2, foo, typeof foo);
console.log(3, foo, typeof foo);
输出为：
1 function foo(){
    console.log("函数声明");
} "function"
2 "变量" "string"
3 "变量" "string"