JS笔记

预编译

1. 创建AO对象
2. 找函数形参和变量声明，值给undefined
3. 实参形参统一
4. 在函数体里面找函数声明，值赋予函数体

function fn(a){
   console.log(a); //在AO里找值--->输出 function a() {}
   var a = 123; //预编译将 var a,提升上去了，执行 a = 123;修改AO中a的值
   console.log(a); //输出 123
   function a() {} //预编译读过，不再读
   console.log(a); //输出 123
   var b = function() {} //函数表达式，将AO中b的值改为function () {}
   console.log(b); //输出funtion () {}
   function d() {}
}
fn(1);

第一步：AO{ }
第二步：
AO{
a : undefined,
b : undefined
}
第三步：
AO{
a : 1,
b : undefined
}
第四步：
AO{
a : function a() {},
b : undefined,
d : function d() {}
}

立即执行函数

此类函数没有声明，在一次执行过后即释放,可以用来做初始化

var mrDeng = (function(){
    var Deng = {
        name : "MrDeng",
        age : 40,
        sex : "male",
        health : 100,
        smoke : function () {
            console.log('I am smoking! cool!!!');
            this.health --;
        },
        drink : function () {
            console.log('I am drink');
            this.health ++;
        }
    }
    return Deng;
}())

这样可以实现初始化的效果

闭包

内部函数被返回到外部，函数本身保留了父函数的AO,即使父元素执行完了，取消对AO的引用，但依旧被子函数保留下来了，就形成了闭包。

闭包会导致原有作用域链不释放，造成内存泄漏。

作用

1. 实现公有变量（累加器）

因为子函数保留有父函数的AO，并在此基础上搭建自己的AO，所以父函数的AO会被作为一个公有变量被使用，即使函数执行完毕，也只会销毁自己创建的AO对象。

2. 实现封装，属性私有化

简单理解就是函数结束会销毁父函数的执行上下文，但是应用闭包可以使父函数的执行上下文被保留下来，给父函数下的其他函数使用，这样就实现了属性的私有化

3. 模块化开发

4. 防止污染全局变量

var name = 'abc';//全局变量
var init = (function() {
    var name = 'ljc';
    function callName() {
        console.log(name);
    }
    return function () {
        callName();
    }//返回一个函数形成闭包，留有父函数的AO{name: 'ljc'}
}())
init();//ljc

5. 缓存（存储结构）

防范

闭包会导致多个执行函数共用一个公有变量，应当尽量避免

利用闭包解决for循环绑定事件的问题

function test(){
   var liCollection = document.getElementByTagName('li');
   for(var i = 0; i < liCollection.length; i++){
      (function (j){
         liCollection[j].onclick = function(){ //把函数绑定到了每个li元素(外部)
            console.log(i);
         }
      }(i))
   }
}
test();