JavaScript（单线行解释型语言）运行三部曲: 1语法分析 2预编译 3 解释执行

知识点：预编译 作用域 闭包 立即执行

预编译

关键语句：

1函数声明整体提升 。

2变量声明只有变量提升。
例如：var a=3;//实际操作是 var a ;a=3；但是只把var a 提升

3 imply global 暗示全局变量：即任何变量如果变量未经声明就赋值此变量就为全局对象所有。
例如：function test(){a=123;console.log(a)} test() 分析：a未声明赋值，a的值是归全局对象(global object )所有 。a的值在GO，写作GO{ a:3}。
再例如：var a=b=3;实际是var a ;a=b=3;只有a被声明了，b是未声明即属于全局变量。

4 一切声明的全局变量，全是window的属性,（Window就是全局的域。）

例如：eg:var a = 123; ===> window.a = 123

预编译步骤

1创建一个AO对象。
2找到形参和变量声明。将 形参和 变量名 作为AO的属性，值为undefined。
3实参和形参统一，即实参赋值给形参。
4在函数体里找函数声明，将值赋予函数体。（）

案例1：

function fn(a)  {
    console.log(a);
    var a=123;
    console.log(a);
    function a(){}
    console.log(a);
    var b=function(){}
    console.log(b);
   function d(){}
   
}

fn(1)

预编译(发生在函数执行的前一刻)
1，创建AO{ }。
2，找到形参 a 和变量声明var a =123中的a,var b中的b,相同的a只写一个，值为undefined。此时AO{a:undefined;b:undefined}。
3,实参和形参统一，即fn(1)的1赋给fn(a)的a。此时AO{ a:1;b:undefined}
4，在fn(a)这个函数体中找函数声明，即有 function a(){}和 function d(){}将值赋给函数体。此时AO{ a:function a(){};b:undefined;d:function d(){}}。
解释执行函数
第一个console.log(a)→function a(){}
a=123即AO{ a:123;b:undefined;d:function d(){}}。
第二个console.log(a)→123。
function a(){} 已经提升上去了，不需要看了。
第三个console.log(a)→123。
b=function(){}即AO{ a:123; b:function(){ } }; d:function d(){}}。
console.log(b)→function(){ }
function d(){} 已经提升上去了，不需要看了。

作用域

关键语句

作用域链：[[scope]]中所存储的执行期上下文对象的集合，这个集合呈链式链接，我们把这种链式链接叫做作用域链。
[[scope]]:[[scope]]指的就是我们所说的作用域,其中存储了运行期上下文的集合。
查找变量：从作用域链的顶端依次向下查找（在哪个函数内就从这个函数的作用域链顶端查找）。

运行期上下文:当函数执行时，会创建一个称为执行期上下文的内部对象。一个执行期上下文定义了一个函数执行时的环境，函数每次执行时对应的执行上下文都是独一无二的，所以多次调用一个函数会导致创建多个执行上下文，当函数执行完毕，执行上下文被销毁。

案例2

var global=100;
function  temp1( ){
    function temp2(){
      function temp3(){
      var global=400;
      console.log(global)//400
      
    }
        var global = temp3;
            temp3();
    console.log(global)// 打印 function temp3()内的所有内容即 function temp3(){var global=400; console.log(global)}
  }
  var global=temp2;
  temp2()
  console.log(global)//打印function temp2()内的所有内容即 function temp2(){function temp3(){var global=400;console.log(global)}var global = temp3;temp3();console.log(global) }
      
 }
    
temp1( )

分析运行时的作用域链
temp1
temp1 -->>defined:GO{ global: 100;fn temp1}
temp1 -->>doing: temp1AO{ global: temp2；fn temp2; }GO{ global: 100;fn temp1;}
temp2 -->>defined:temp1AO{ global: temp2;fn temp2; }GO{ global: 100;fn temp1;}
temp2 -->>doing:temp2AO{ global: temp3;fn temp3; } temp1AO{ global: temp2;fn temp2; }GO{ global: 100;fn temp1;}
temp3 -->>defined:temp2AO{ global: temp3;fn temp3; }temp1AO{ global: temp2;fn temp2; }GO{ global: 100;fn temp1;}
temp3 -->>doing:temp3AO{ global=400} temp2AO{ global: temp3;fn temp3; }temp1AO{ global: temp2;fn temp2; }GO{ global: 100;fn temp1;}

闭包

关键语句

1，当内部函数被保存到外部将会生成闭包。原有作用域链不释放，造成内存泄漏。
2，闭包作用：
实现公有变量:函数累加器。
可以做缓存:eater。
可以实现封装，属性私有化: Person()。
模块化开发，防止污染全局变量。

//简单函数累加器，内部函数b被保存到外部用一个变量add接受，且原有的作用域链也一起保存到外部。
function a(){
  var count=0;
  function b(){ 
   
  console.log(count++);
  
   }
 return b;
  
}

var add=a();
add();

//函数缓存案例


 function test() {
              var food = "apple";
              var obj = {
                eatFood: function() {
                    if (food != "") {
                        console.log("I am eating  " + food);
                        food = "";
                    } else {
                        console.log("nothing")
                    }
                },
                pushFood: function(myFood) {
                    food = myFood;




                }

            }
            return obj;
        }
        var person = test();
        person.eatFood(); //I am eating apple
        person.eatFood(); //nothing
        person.pushFood("banana"); //food ="banana"
        person.eatFood(); //I am eating  banana

下面是 闭包 和 立即执行函数 运用案例

//i=10,for循环才不执行，传给数组的i的值是最后改变成的结果 i=10。共执行10此，因此是10个10。
function test() {
            var arr = [];
            for (var i = 0; i < 10; i++) {
              
                    arr[i] = function() {
                        console.log(i);//10个10
        
            }
            return arr;

        }

        var myArr = test();


        for (j = 0; j < 10; j++) {
            myArr[j]();//将数组打印，j只用于计数，可以为任意字母。

        }

//若想输出值是0~9，必须保证每次给到arr[]的i后 不能因为i++保存打印函数受影响。可以适应立即执行函数，执行完销毁，并且将i作为实参 传递给arr[]。
function test() {
            var arr = [];
            for (var i = 0; i < 10; i++) {
                (function(j) {
                    arr[j] = function() {
                        console.log(j);//0~9
                    }



                }(i))


            }
            return arr;

        }

        var myArr = test();


        for (j = 0; j < 10; j++) {
            myArr[j]();

        }//将数组打印，j和上面函数的j 无关，j只用于计数数组，可以为任意字母。

立即执行函数

关键语句 （只有表达式才能被执行）
写法：推荐写法→（ function（）{} （））也可以写作（不推荐） →（ function（）{} ）（）
作用：执行后即刻销毁，所以可以用作初始化

其他知识点

var a=(b,c);//逗号操作符，先运行b,再运行c,最后把b的运行结果赋给a。

var f=(   
          function  f() {return "1";},
         function  g() {return 2;}
)（）；
typeof f；//数字2

PS：关于闭包的其他作用目前尚未有案例，后续将会补充。