Chaîne de portée JavaScript et environnement d'exécution

Les concepts de portée, de chaîne de portée, d'environnement d'exécution, de pile d'environnement d'exécution et cela sont très importants en JavaScript, je les confonds souvent

1. La zone à l'intérieur de la fonction de portée locale, la portée globale est window

2. La chaîne de portée dépend de la position lorsque la fonction est déclarée. Lors de l'analyse de l'identifiant, la portée actuelle est la première. trouvé. Ensuite, recherchez vers l'extérieur jusqu'au monde entier, un tel ordre ; cela n'a rien à voir avec l'endroit où la fonction est appelée

3. L'environnement d'exécution est la collection de données et de variables accessibles à ; la fonction, qui est la portée de la fonction Toutes les données et variables de la chaîne

4. La pile de l'environnement d'exécution est basée sur l'ordre d'exécution du code. Chaque couche d'environnement d'exécution est accessible par. couche sous la forme d'une pile, et sort et se jette une fois utilisé ; si l'environnement d'exécution actuel (qui stocke les données et les variables dans la chaîne de portée actuelle) ne trouve pas la variable, cela signifie qu'elle ne peut pas être trouvée. pas de recherche dans l'environnement d'exécution précédent. C'est différent de la chaîne de portée

• Une variable qui n'est pas déclarée dans une fonction ou déclarée sans var est une variable globale et a une portée globale

        <script type="text/javascript">
            function test1(){
                a = 1;//全局变量，只有在当前函数运行时，才有效            }
            test1();
            console.log(a);//1       注意test1函数必须运行，不然找不到a
        </script>

• Les variables globales peuvent être utilisées comme attributs de l'objet fenêtre, elles sont identiques

        <script type="text/javascript">    
            var b = 1;//全局变量            
            console.log(b === window.b);
            //true  全局变量可以当做window对象的属性用，他们是一样的；
        </script>

• Tous les attributs de l'objet fenêtre ; avoir une portée globale, accessible n'importe où dans le code ;

• Les variables déclarées à l'intérieur de la fonction sont des variables locales et ne peuvent être utilisées que dans le corps de la fonction. utilisez var, ce sont toujours des variables locales.

        <script type="text/javascript">    
            var c = 1;//全局变量//            
            console.log(d);//ReferenceError: d is not defined    引用错误，当前作用域就是最外层作用域，依然找不到d
            function test2(d){
                console.log(c);
                //1   全局变量，哪都可以访问;（先找当前作用域，找不到，就向外层作用域找，直到window最外层，找到了）                console.log(d);//3   形参是局部变量，只有当前作用域下可以访问            }
            test2(3);        
            </script>

Son itinéraire a été déterminé et n'a rien); à voir avec l'endroit où la fonction s'exécute

        <script type="text/javascript">
            var a = 1;            
            var b = 2;            
            var c = 3;            
            var d = 4;            
            function inner(d) {//它的作用域链是inner---全局
                var c = 8;
                
                console.log(a);//1  当前作用域找不到a，去全局作用域找到了a=1                console.log(b);//2  当前作用域找不到b，去全局作用域找到了b=2                console.log(c);//8  当前作用域找到了c=8                console.log(d);//7  当前作用域找到了d=7,形参也是局部作用域
            //    console.log(e);//ReferenceError: e is not defined   引用错误，找不到e, 它的作用域链是inner---全局                console.log(a+b+c+d);//18            }            function outter(e) {                var a = 5;//inner()的作用域链是inner---全局,所以这个a相当于无效
                var b = 6;//inner()的作用域链是inner---全局,所以这个a相当于无效                inner(7);
            }
            outter(999);//这个999无效，里面的e根本找不到
        </script>

Les identifiants portant le même nom peuvent être définis dans des portées imbriquées à plusieurs niveaux, ce qui est appelé "effet d'ombrage" , l'identifiant interne "obscurcit" l'identifiant externe
Grâce à la technologie window.a, vous pouvez accéder aux variables globales qui sont masquées par des variables du même nom. Mais si les variables non globales sont masquées, elles ne sont de toute façon pas accessibles

        <script type="text/javascript">
            var a = &#39;Lily&#39;;            
            var b = &#39;Lucy&#39;;            
            function outer() {                
            var b = &#39;Jesica&#39;;                
            var c = &#39;Susan&#39;;                
            function inner(c) {
                console.log(a);//Lily                      
                console.log(window.b);//Lucy                    
                console.log(b);//Jesica                    
                console.log(c);//Jenifer                
                }
            inner(&#39;Jenifer&#39;);
          }
            outer();       
         </script>

Contexte d'exécution, également appelé contexte d'exécution. Chaque environnement d'exécution possède un objet variable (variable

) qui enregistre toutes les variables et données accessibles à la fonction (c'est-à-dire toutes les données et variables de la chaîne de portée de la fonction). Notre code ne peut pas y accéder, il est utilisé par le moteur ; Pile d'environnement d'exécution Lorsque l'exécution entre dans une fonction, l'environnement d'exécution de la fonction sera poussé dans une pile. Une fois la fonction exécutée, la pile supprime son environnement d'exécution, les variables et les données qu'elle contient seront marquées et effacées, attendra le garbage collection, puis rendra le contrôle à l'environnement d'exécution précédent. L'exécution dans le programme javascript est contrôlée par ce mécanisme ;

L'ordre d'exécution du code n'est pas tout ligne par ligne, mais le ordre d'appel de la fonction. Connexe :

• Lorsqu'une fonction est exécutée, cet environnement d'exécution de la fonction est poussé en haut de la pile d'environnement, avec l'environnement d'exécution précédent à l'arrière

• L'environnement d'exécution global ; est entré en premier, donc il est toujours en bas ; c'est similaire au concept de pile

• Une fois la fonction exécutée, son environnement d'exécution est supprimé du haut de la pile ; chaîne de portée. Les données et les fonctions qu'il enregistre sont marquées et effacées, en attente de garbage collection

• Le contrôle est transféré à l'environnement d'exécution précédent et l'exécution continue
• ;
  L'environnement d'exécution global est détruit lorsque la page est fermée

• L'exécution de code entre dans l'environnement d'exécution global et le code dans l'environnement d'exécution global entre dans la promotion de l'instruction ;

• Exécutez la ligne 2, attribuez a=1 ; puis la ligne 2, la ligne 3 attribue b=2 ; puis la ligne 4 attribue c=3 ; puis la ligne 5 attribue d=4 ; >

• Exécutez la ligne 20, appelez la fonction external(999), puis entrez dans l'environnement d'exécution de la fonction external(999), déclarez la promotion et transmettez le paramètre réel 999 au paramètre formel e ; Deux environnements d'exécution, external(999) est l'environnement d'exécution actuel

• exécute la ligne 16, attribue a=5 puis attribue b=6 à la ligne 17 ;

Exécutez la ligne 18, appelez la fonction inner(7), puis entrez dans l'environnement d'exécution de la fonction inner(7), déclarez la promotion et transmettez le paramètre réel 7 au paramètre formel d
Exécuter la ligne 7, attribuer c=8 ; puis opérer et sortir ;
Optimisation du code

Puisqu'il est nécessaire de trouver des variables sur le scope chain Pour consommer des performances, nous devons trouver les variables le plus tôt possible, donc lorsque les fonctions sont imbriquées dans plusieurs couches, nous devons autant que possible utiliser des variables locales à l'intérieur de la fonction

On peut dire que nous utilisons globales ; variables à l'intérieur de la fonction. Une opération multi-portée. Si une valeur multi-portée est utilisée plusieurs fois dans la fonction, nous la stockons dans une variable locale, ce qui peut améliorer les performances.

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!