JS中的 作用域

作用域

标识符（变量和函数名）在哪些地方能够被访问，那些地方就是这个标识符的作用域。

这些地方是指：函数的代码块内部和函数的代码块内部

规则1：函数内部的代码可以访问函数内部的标识符，也可以访问函数外部的标识符（一级一级向上找，直到找到全局作用域 window）。

规则2：函数外部的代码可以访问函数外部的标识符，但是不能访问函数内部的标识符

    <script>
        var num1 = 10;         //函数外部标识符
        function fn(){
            var num2 = 20;     //函数内部标识符
            console.log(num1,num2); //10  20
        }
        console.log(num1,num2); //10 未找到num2
    </script>

通常：函数内部的标识符称为局部标识符。 

    <script>
        function fn(a){
            //隐式声明 var a = 200
            function fm(a){
                //隐式声明： var a = 200
                console.log(a,111111);  //200
                a = 90;                 //把fm作用域中的a 改为90
                console.log(a,222222);  //90
            }
            fm(a);   //fm(200)
            console.log(a,333333333);   //fn作用域中a=200
        }
        var a = 200;   //
        fn(a);   // a = 200,传入fn  fn(200)
        console.log(a,44444444);   //访问不到函数内部，只能访问全局作用域中的a = 200
    </script>

变一下：

    <script>
        function fn(a){
            //隐式声明 var a = 200
            function fm(){    //虽然传入了a,但是函数并没有接收
                console.log(a,111111);   //fm作用域中没a，去fn中找到a = 200
                a = 90;                  //把fn中a改为200          
                console.log(a,222222);   //去到fn中找a为 90
            }
            fm(a);  
            console.log(a,333333333);    //fn中a已经被改为90
        }
        var a = 200;   
        fn(a);   
        console.log(a,44444444);        //依旧是全局a 为200
    </script>

规则3:函数的调用是运行一次其函数体，每一次调用都会重新执行所有代码，会在不同内存空间，（每次调用执行的函数体，互不影响）

局部变量和全局变量的区别：

局部变量是函数每次调用都会重新生成，全局变量是无论函数调用了多少次，全局变量的代码运行的那一刻，只生成一次。

    <script>
        var total = 0;   //全局变量
        function increment(){
            var total = 0;    //局部变量
            total += 2;
            console.log(total);
        }
        increment();    //2
        increment();    //2
    </script>

 

同名标识符的提升问题

规则1:每一个作用域在运行时，js引擎会先把作用域内部的关键字隐式提前扫描，并声明，但赋值没提升。

规则2：函数也会隐式提升，变量是把声明提升，函数是提升的整个函数体。

规则3：只有变量的 和函数的声明式写法才会提升，对象内部的方法不会隐式提升。

规则4：如果声明的函数名和变量名相同，先提升变量名，再提升函数名

    <script>
        console.log(a);  //得到的是a函数
        var a = 10;
        function a(){
            console.log(999);
        }
        /*
            因为：变量先提升，函数后提升
            var a;
            function a(){console.log(999);} 
            console.log(a);  //所以才取到a函数
            a = 10
         */
    </script>

规则5：设计到隐式声明，函数提升和变量提升的法则：形实函运   顺序：从前往后

形：形参和变量的声明提升是一起的

实：实参的赋值  传入进来的实参赋值给变量

函：函数声明提升

运 ：运行后续的代码

    <script>
        var a = 20;

        function fn(a) {
            /*
                设计到隐式声明，函数提升和变量提升的法则：形实函运
                var a;     //形：形参的隐式声明var a 和 变量声明的提升 var a是一起的 
                a = 20;    //实：传入进来的实参赋值给变量a
                function a() {console.log(66666); } //函:函数声明提升
                          //运  运行后续的代码
            */
            console.log(a, 1); // 易错认为是20  ，是a函数
            a = 90;
            console.log(a, 2); //90
            var a = 100;
            console.log(a, 3);//100

            function a() {
                console.log(66666);
            }
            console.log(a, 4);  //100
        }
        fn(a);
    </script>

规则6：函数是一个引用数据，标识符可以在任何作用域去引用一个函数，但是：函数运行时的作用域在函数在生成时(定义和声明)时，所在的作用域。 

通俗说就是：函数运行是在写函数块代码的地方运行含代码，不是在函数调用的地方运行代码（因为有可能：函数声明的地方和函数调用的地方相差很远。但要明白就是：函数运行时的作用域在函数在生成时(定义和声明)时，所在的作用域。）

    <script>
        function fn(a){
            //隐式声明 var a = 10   //第一次调用fm函数改为11  第二次调用改为12
            function fm(){
                a = a + 1;
                console.log(a);
            }
            return fm;
        }
        var f1 = fn(10); //返回fm函数
        f1();   //11
        f1();   //12
    </script>

分析：fn只调用一次，只生成一个fn作用域，fm调用两次，生成两个fm作用域，但两个fm作用域都是在fn里面，所以fn里面的变量a被两个内部的fm作用域里面的a=a+1,改了两次，第一次改然后打印为11，第二次改然后打印为12.所以结果一次为11，一次为12 

    <script>
        function fn(a) {
            function fm() {
                a = a + 1;
                console.log(a);
            }
            return fm;
        }
        var f1 = fn(10); //返回fm函数
        f1(); //11
        var f2 = fn(10);
        f2(); //11
    </script>

 分析:fn调用了两次，生成了两个fn作用域，每个fn作用域中生成一个fm作用域，所以是一个fn作用域里面包含一个fm作用域，所以两个fn作用域中a分别被各自的fm作用域中的a =a+1修改一次，所以两个都是打印11