作用域

        // 1.JavaScript作用域 ： 就是代码名字（变量）在某个范围内起作用和效果 目的是为了提高程序的可靠性更重要的是减少命名冲突
        // 2. js的作用域（es6）之前 ： 全局作用域   局部作用域 
        // 3. 全局作用域： 整个script标签 或者是一个单独的js文件
        var num = 10;
        var num = 30;
        console.log(num);
​
        // 4. 局部作用域（函数作用域） 在函数内部就是局部作用域 这个代码的名字只在函数内部起效果和作用
        function fn() {
            // 局部作用域
            var num = 20;
            console.log(num);
​
        }
        fn();

变量的作用域

在JavaScript中，根据作用域的不同，变量可以分为两种：

• 全局变量

  • 函数外部 （在全局作用域下的变量 在全局下都可以使用 ）
  • 注意 如果在函数内部 没有声明直接赋值的变量也属于全局变量
  • 在全局作用域下声明的变量叫做全局变量（在函数外部定义的变量）。  全局变量在代码的任何位置都可以使用  在全局作用域下 var 声明的变量 是全局变量  特殊情况下，在函数内不使用 var 声明的变量也是全局变量（不建议使用）

  • 
        var num = 10; // num就是一个全局变量
        console.log(num);
      
        function fn() {
            console.log(num);
      
        }
        fn();
        // console.log(aru);
    

  
  ​
  

• 局部变量

• 函数内部 （在局部作用域下的变量   后者在函数内部的变量就是 局部变量 ）

• 注意： 函数的形参也可以看做是局部变量

• 在局部作用域下声明的变量叫做局部变量（在函数内部定义的变量）  局部变量只能在该函数内部使用  在函数内部 var 声明的变量是局部变量  函数的形参实际上就是局部变量

• 
    function fun(aru) {
        var num1 = 10; // num1就是局部变量 只能在函数内部使用
        num2 = 20;
    }
    fun();
    // console.log(num1);
    // console.log(num2);
    // 3. 从执行效率来看全局变量和局部变量
    // (1) 全局变量只有浏览器关闭的时候才会销毁，比较占内存资源
    // (2) 局部变量 当我们程序执行完毕就会销毁， 比较节约内存资源
  

```
​

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

  • 全局变量：在任何一个地方都可以使用，只有在浏览器关闭时才会被销毁，因此比较占内存
  • 局部变量：只在函数内部使用，当其所在的代码块被执行时，会被初始化；当代码块运行结束后，就会被 销毁，因此更节省内存空间

作用域链

内部函数访问外部函数的变量，采取的是链式查找的方式来决定取那个值 这种结构我们称为作用域链   就近原则

• 只要是代码，就至少有一个作用域
• 写在函数内部的局部作用域
• 如果函数中还有函数，那么在这个作用域中就又可以诞生一个作用域
• 根据在内部函数可以访问外部函数变量的这种机制，用链式查找决定哪些数据能被内部函数访问，就称 作作用域链

    // 案例 ：结果是几？

    var a = 1;

    function fn1() {
        var a = 2;
        var b = '22';
        fn2();

        function fn2() {
            var a = 3;
            fn3();

            function fn3() {
                var a = 4;
                console.log(a); //a的值 ? 4
                console.log(b); //b的值 ? 22
            }
        }
    }
    fn1();

函数，作用域链，作用域的关系

1.浏览器会专门有一个空间执行js代码----执行环境栈
2.发现有函数 会把函数丢到栈内存里面（0级栈---1级栈--2级栈）
3.此时函数里面的代码是代码字符串，没有任何的价值。
4.当执行的时候会把实参赋值给形参，代码字符串取消
5.当发现变量会根据作用域链依次向上查找--直到找到全局
6.函数执行完毕会立刻销毁（闭包不会销毁）
tip：栈内存---局部作用域----局部变量
​

预解析

​ 1. 我们js引擎运行js 分为两步： 预解析 代码执行

​ (1). 预解析 js引擎会把js 里面所有的 var 还有 function 提升到当前作用域的最前面

​ (2). 代码执行 按照代码书写的顺序从上往下执行

​ 2. 预解析分为 变量预解析（变量提升） 和 函数预解析（函数提升）

​ (1) 变量提升 就是把所有的变量声明提升到当前的作用域最前面 不提升赋值操作

​ (2) 函数提升 就是把所有的函数声明提升到当前作用域的最前面 不调用函数

• 注意：

  • 全局变量访问不到局部变量
  • 函数内部加了var关键字就是局部的，形参也是局部的
  • 没有加var关键字或者没有传递参数 此时 a=1 就是全局的

        f1();
        console.log(c);
        console.log(b);
        console.log(a);
​
        function f1() {
            var a = b = c = 9;
            console.log(a);
            console.log(b);
            console.log(c);
        }
        // 以下代码
        // function f1() {
        //     var a;
        //     a = b = c = 9;
        //     // 相当于 var  a  = 9; b = 9; c = 9; b 和 c 直接赋值 没有var 声明 当 全局变量看
        //     // 集体声明  var a = 9, b = 9, c = 9;
        //     console.log(a);//9
        //     console.log(b);//9
        //     console.log(c);//9
        // }
        // f1();
        // console.log(c);//9
        // console.log(b);//9
        // console.log(a);//报错 因为var a为局部变量，全局变量不能调用局部变量

预解析案例：

    var a = 0;
    function aa() {
        alert(a)
        var a = 3
    }
    aa();
    提升：
        var a;
    function aa() {
        var a;
          alert(a)
        a = 3;
      }
      a = 0
      aa()
    知识点：  如果局部作用域有对应的变量 就不会向上查找
案例2：
    var a = 0;
    function aa(a) {
        alert(a)
        var a = 3
    }
    aa(5)
    alert(a)
    // 提升：
    var a;
    function aa(a) {
        var a;
        alert(a)
        a = 3
    }
    a = 0
    aa(5)
    alert(a)//0
   知识点：
         实参覆盖形参 那么形参目前=5  形参和变量重名 以形参为主
案例3：
    function aaa() {
       var a = 10;
    };
    aaa();
    alert(a);//全局访问不了布局的。
   知识点：
        函数内部加了var关键字就是局部，   
        形参也是局部
        没有加var关键字 或者 没有传递参数 那此时a就是全局的。
案例4：
    var a = 10;
    function aaa() {
        alert(a);
    };
    function bbb() {
        var a = 20;
        aaa();
    }
    bbb();
   知识点：
    函数的作用域是根据定义时的位置，而不是调用时的位置
案例5：
    console.log(a);
    var a = 1;
    console.log(a)
    function a() { console.log(123) };
    // 提升
    var a;
    function a() { console.log(123) };
    console.log(a);//函数
    a = 1
    console.log(a)//1
    知识点：
        函数名也会提升。
案例6：
    var a = 1;
    function fn(a) {
        console.log(a);
        a = 2;
    };
    fn();
    解析： a是一个形参  没有实参 那a结果是undefined 
    console.log(a); //1
   知识点：
        a是形参， 形参没有实参 结果是undefined。 只要传递了形参就不会向上一级查找
案例7：
    var a = 1;
    function fn(a) {
        console.log(a);
        var a = 2;
        function a() { }
        console.log(a);
    }
    fn();
    解析：
    var a;
    function fn(a) {
        var a;
      function a() { }
        console.log(a);函数
        a = 2;
        console.log(a); 2
    }
    a = 1
    fn();
案例8：
    alert(a)
    a();
    var a = 3;
    function a() {
        alert(10)
    }
    alert(a)
    a = 6;
    a();
    提升：
    var a;
    function a() {
        alert(10)
    }
    alert(a) //函数
    a();//10
    a = 3;
    alert(a)//3
    a = 6;
    // a();报错