闭包

闭包作用（保护）

形成私有作用域，保护里面的私有变量不受外界的干扰

jQuery：常用的JS类库，提供了很多项目中常用的方法（兼容所有浏览器）
Zepto：小型JQ，专门为移动端开发准备的

1.//=>JQ代码片段
2.(function(window){
3.    var jQuery=function(){
4.        ...
5.    };
6.    ...
7.
8.    window.jQuery=window.$=jQuery;
9.})(window);
10.
11.jQuery()
12.$()
13.
14.//=>Zepto的代码片段
15.var Zepto=(function(){
16.    var Zepto=function(){
17.        ...
18.    };
19.    ...
20.    return Zepto;
21.})();
22.var $=Zepto;
23.Zepto();
24.$();

真实项目中，我们利用这种保护机制，实现团队协作开发（避免了多人同一个命名，导致代码冲突的问题）

1.//=>A
2.~function(){
3.    //=>A写的代码
4.    function fn(){
5.        ...
6.    }
7.    window.fn=fn;
8.}();
9.
10.//=>B
11.~function(){
12.    //=>B写的代码
13.    function fn(){}
14.
15.    //=>B想要调取A写的fn
16.    window.fn();
17.}();

闭包作用（保存）

函数执行形成一个私有作用域，函数执行完成，形成的这个栈内存一般情况下都会自动释放

但是还有二般情况：函数执行完成，当前私有作用域（栈内存）中的某一部分内容被栈内存以外的其它东西（变量/元素的事件）占用了，当前的栈内存就不能释放掉，也就形成了不销毁的私有作用域（里面的私有变量也不会销毁）

i++和++i的区别

i++：先拿原有i的值和其它值进行运算，运算完成后在自身累加1
++i：先自身累加1，然后拿累加完成的结果和其它值进行运算

1.var i=5;
2.console.log(5+i++);//->10  5+(i++) 加括号也是先运算在累加1
3.console.log(i);//->6
4.
5.i=5;
6.console.log(5+(++i));//->11
7.console.log(i);//->6

函数执行形成一个私有作用域，如果私有作用域中的部分内容被以外的变量占用了，当前作用域不销毁
[形式]
函数执行返回了一个引用数据类型堆内存的地址（并且堆内存隶属于这个作用域），在外面有一个变量接收了这个返回值，此时当前作用域就不能销毁（想要销毁，只需要让外面的变量赋值为null，也就是不占用当前作用域中的内容了）

1.function fn() {
2.    var i = 1;
3.    return function (n) {
4.        console.log(n + i++);
5.    }
6.}
7.var f = fn();
8.f(10);//->11
9.fn()(10);//->11
10.f(20);//->22
11.fn()(20);//->21

严格模式和非严格模式的区别

• 严格模式下不支持arguments.callee和arguments.callee.caller.
• 在严格模式下arguments和形参没有映射机制
• 在严格模式下不允许给一个对象设置重复属性名的
• 在严格模式下函数执行如果没有明确指定函数的主体（函数前面没有点），不像非严格模式下一样统一都交给window，而是让this指向undefined，代表没有执行主体：“严格模式下有执行主体this就指向谁，没有执行主体this就是undefined”
• 高程3最后有严格模式和非严格模式的汇总。

function fn(x, y) {
    var arg = arguments;
    /*
     * x=10 y=undefined
     *
     * ARG
     *  0:10
     *  length:1
     */
    // y = 200;
    // console.log(arg[1]);//=>undefined

    arg[1] = 300;
    /*
     * ARG
     *  0:10,
     *  1:300,
     *  length:2
     */
    console.log(y);
    y=400;
    console.log(arg[1]);

    //=>ARGUMENTS和形参的映射机制建立在函数执行后形参赋值的一瞬间，此时能建立映射机制的建立映射机制，不能建立起来的，以后不管怎么操作都无法再建立了
}
fn(10);


----------
"use strict";
var a = 4;
function b(x, y, a) {
    console.log(a);//=>3
    arguments[2] = 10;
    console.log(a);//3
}
a = b(1, 2, 3);//=>undefined