js analyse de la portée de l'ordre d'analyse en mode strict

1. L'ordre d'analyse de JavaScript

Nous comprenons tous que l'ordre d'exécution du code est de haut en bas, mais en fait ce n'est pas comme ça. Jetons un coup d'œil au code ci-dessous.

1 alert(a);
2 var a = 1;

Si l'ordre d'exécution est de haut en bas et qu'un a apparaît dessus, le navigateur pensera qu'il est exécuté de haut en bas, alors lorsqu'il alerte (a), il constatera qu'une telle chose n'existe pas, puis il signalera une erreur, mais en fait le résultat qu'il affiche n'est pas défini. La valeur de retour est indéfinie, ce qui indique que a n'est pas défini, c'est-à-dire qu'aucune valeur ne lui est attribuée. Maintenant, laissez-moi vous expliquer l'ordre d'analyse de javascript.

1. Les mots-clés déclaratifs dans ES5

var auront une promotion de variable

la fonction aura également pour fonction de déclarer des variables.

2. Ordre d'analyse

1. Recherchez la déclaration var, déclaration de fonction : déclarez uniquement les variables, pas les affectations.

2. Exécuter

Remarque : les deux étapes ci-dessus sont suivies de haut en bas. Lors de l'exécution du signe égal, regardez d'abord le côté droit du signe égal.

Remarque : Lorsque la variable déclarée par fonction a le même nom que la variable déclarée par var, le poids variable de la fonction sera supérieur à celui déclaré par var.

Ce sera beaucoup plus clair avec quelques exemples supplémentaires ci-dessous, mais avant de regarder les exemples, vous devez savoir ce qu'est la portée.

2. Portée

La portée est la suivante : le champ d'action est divisé en deux types suivants

1. Portée globale

2. Rôle fonctionnel Domaine

La différence entre eux est analysée en détail dans l'exemple suivant.

3. Regardons quelques exemples pour analyser les étapes de la séquence d'exécution

1. Premier exemple :

var x = 5;
    a();    
function a(){
        alert(x);        
        var x = 10;
    }
alert(x);

Processus d'analyse

1. Recherchez la déclaration (voir portée globale)

var x;

function a(){}

2. Exécutez

 > 　　　　　 1. Recherchez l'étape de déclaration var, puis la chose contextuelle est indéfinie ; est indéfinie 5

2. Le deuxième exemple

Le processus d'analyse est le même que dans l'exemple ci-dessus

1. Rechercher la déclaration

　fonction a(){}

　2. Exécution

　a()-------------------------------- ------>Fonction

　　　　　1. Rechercher la déclaration

　　　　　var x; popup undefined

<p style="margin-bottom: 7px;">a() function a(){<br/>    alert(x);    <br/>    var x = 10;<br/> }<br/>alert(x);<br/></p>

　　　　　x = 10;

Je crois que tous ceux qui ont lu ces deux exemples ont une compréhension claire de ce processus d'analyse. Si vous ne le comprenez toujours pas bien, il est recommandé de le revoir.

Ce qui suit présente quelques éléments qui nécessitent une attention particulière. Passons directement à l'exemple

3. Le troisième exemple

Comme mentionné précédemment, lorsque les variables déclarées par fonction et les variables déclarées par var se chevauchent. Lorsqu'elle est nommée, le poids variable de la fonction sera supérieur à celui déclaré par var. Prenons un exemple pour prouver

Processus d'analyse

1. Recherchez l'instruction

fonction a(){}

var a;

2. Exécuter

alert (a) Comme mentionné précédemment, la déclaration de fonction a un poids plus élevé que la déclaration var, donc quand ceci est exécuté, ceci le bloc fonctionnel apparaîtra ( Function body)

a = 1;

alert(a); Ce qui apparaît ici est 1

Le résultat final est donc le bloc fonctionnel 1. ;

4. Le quatrième exemple

La portée enfant peut rechercher des variables dans la portée parent jusqu'à ce qu'elle atteigne la portée globale, mais pas l'inverse. Si la portée enfant a la même variable, alors il utilisera la sienne et ne la demandera pas à son père.

alert(a)function a() {
    alert("函数")
}var a = 1;  
alert(a)

Processus d'analyse

1. Recherchez l'instruction

var a;

function fn() { }

2. Exécuter

a = 5;

fn()-------------------- - -------------------> Fonction

1. Rechercher la déclaration

2. Exécuter

　　　　　　　　　　　　　　　　　　　　　alert(a); 他这里没有a 所以去找爸爸要。 a = 5； 所以弹窗是 5

　　所以最后结果为 弹窗5

　　下面看一下爸爸会不会去找儿子要东西

function fn(){    
      var b = 5; 
    return b;    
}
fn();
alert(b);

　　1.寻找声明

　　　　function fn(){}

　　2. 执行

　　　　fn（）----------------------------------------> 函数

　　　　　　　　　　　　　　　　　　　　　　1.寻找声明

　　　　　　　　　　　　　　　　　　　　　　　　1.var b;

　　　　　　　　　　　　　　　　　　　　　　2.执行

　　　　　　　　　　　　　　　　　　　　　　　　return b;

　　alert(b); //我们看一下返回值是多少 b is not defined 他说b没有被定义，说明父作用域不可以向自作用域去寻找变量。

　5. 第五个例子

　　当一个变量无中生有时，不管从哪个作用域出来的，统统归到window下，下面看两个例子

  fn();
  alert(a);  var a = 0;
  alert(a);  function fn(){     var a = 1;
  }

这一个例子应该可以自己分析了 最后的结果是 undefined 0

我们再来看一下下面这个你会很吃惊

  fn()
  alert(a)  
  var a = 0;
  alert(a);  
  function fn(){
      a = 1;
  }

　　明明都一样，我吃惊什么 返回值不是还是 undefined 和 0 吗

　　但是你有没有发现倒数第二行 上面的声明了 下面的没有声明，来解析一波

　　1.寻找变量

　　　　var a;

　　　　function fn(){}

　　2.fn()---------------------------->函数

　　　　　　　　　　a = 1; 这个时候就说到了那一点，无中生有的变量，统统归到window下面

　　所以下面的执行过程

　　alert(a) 这里的弹窗就是 1 了

　　 a = 0;

　alert(a) 弹出 0

　　所以最后的结果是 1 0

四、严格模式

　　严格模式下的代码执行时，非常严格

　　变量不允许无中生有

　　意义：规范代码开发的流畅，逻辑

"use strict"a = 1；
alert(a);

当我们写后面两句代码的时候不会报错和出现问题，但是当我们加上第一句代码的时候，我们在这样写的时候就会报错了。所以我们还是按照规范的标准来,提高自己的能力

五、可能好多人做了上面的例子感觉不太过瘾，下面我再给出几个例子，可以自己去分析分析，我会在最后面给出答案。

1.　第一个例子　 // 10 报错

var a = 10;
alert(a);
a()function a(){
    alert(20);
}

2.第二个例子 undefined 1 0

var a = 0;    
function fn(){
        alert(a);        
        var a = 1;
        alert(a);
    }
    fn();
    alert(a);

3.第三个例子 当同样的声明同样的名字重复时，后面写的会覆盖前面写的 //2 1 1 3

 a()    var a = function(){
        alert(1)
    }
    a();    function a(){
        alert(2);
    }
    a();    var a = function(){
        alert(3);
    }
    a()

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!