作用域闭包

闭包是基于词法作用域书写代码产生的自然结果
当函数可以记住并访问所在的此法作用域的时候，就产生了闭包

 var  a=2;
    (function () {
        console.log(a);
    })()

由上面的定义就知道，上面的代码并不是严格意义上的闭包。因为并没有在函数本身创建的此法作用域以外执行。
。也就是当前词法作用域之外执行。

    function  foo() {
        var a=2;
        function bar() {
            console.log(a)
        }
        bar();
    }
    foo();

但是上面的这个不是严格意义上的闭包，下面这个程序是严格意义上的闭包

   function  foo() {
        var a=2;
        function bar() {
            console.log(a)
        }
      return bar;
    }
    var baz=foo();
    baz();

一个实际意义上的完整的闭包。
bar()的此法作用域能够访问foo() 的内部作用域。然后将bar(）函数本身当作一个值进行传递。也就是在这个例子中，bar所引用的函数对象本身当作返回值。所以bar在自己定义的词法作用域以外的地方被执行。
闭包的缺点：
在foo执行之后，我们通常会期待foo的整个作用域都被销毁。但是实际上并没有。foo()的内部作用域依然存在，因此没有被 回收。bar()本身还在使用这个作用域。这个作用域会一直存活，以供bar()在任何时间被调用。
闭包：bar（）依然持有该作用域的的引用，这个引用就是闭包。
简单的说闭包就是那个会一直存在的作用域。。

闭包的其他出现的形式；

函数类型作为参数进行传递
无论使用何种方式对函数的值进行传递，当函数在别出被调用时可以观察到闭包。

 function  foo() {
        var a=2;
        function baz() {
            console.log(a)  //2
        }
      bar(baz)
    }
    function bar(fn) {
        fn();     //这也是闭包
    }
    foo();

所以闭包在定时器、事件监听器、AjAx请求，跨窗口通信，web workers或者任何异步或者同步的任务中，只要使用回调函数，实际上就是在使用闭包。

循环和闭包

  for(var i=0;i<=5;i++){
        setTimeout(function timer() {
            console.log(i);
        },i*1000);
    }

运行的结果是每隔一秒就会输出一个6.
原因：延迟函数的回调会在循环结束的时候才执行。尽管循环中的5个函数是在各个迭代中分别定义的，但是他们被封闭在一个共享的全局作用域中，因此实际上只有一个i。
解决办法是：每次循环的时候都要分别为自己保留一个i的副本。

   for(var i=0;i<=5;i++){
        (function (i) {
            setTimeout(function timer() {
                console.log(i);
            },i*1000);
        })(i)
    }

以上代码就实现了每隔一秒就输出0，1，2，3，4，5

 for(var i=0;i<=5;i++){
        let j=i;
            setTimeout(function timer() {
                console.log(j);
            },j*1000);

    }

以上代码就实现了每隔一秒就输出0，1，2，3，4，5，使用let关键字让每一次循环都新生成一个作用域，执行延迟函数。

 for(let i=0;i<=5;i++){
            setTimeout(function timer() {
                console.log(i);
            },i*1000);
    }

以上代码就实现了每隔一秒就输出0，1，2，3，4，5。变量在循环的过程中不止被声明一次每次迭代都会声明。随后的每个迭代都会使用上一个迭代结束时的值来初始化这个变量。

模块

function CoolModule() {
        var something="cool";
        var another=[1,2,3];
        function doSomething() {
            console.log(something);
        }
        function doAnother() {
            console.log(another.join("!"));
        }
        return {
            doSomething:doSomething,
            doAnother:doAnother
        }
    }
    var module=new CoolModule();
    module.doSomething();
    module.doAnother();

这种模式就被称为模块。CoolModule这个名字一定要起得非常有意义和独特。
分析上面的这种模块的模式：
首先：CoolModule（）只是一个函数，必须要通过调用它创建一个模块的实例。如果不执行外部函数，内部作用域和闭包都无法创建。
其次：CoolModule（）返回一个用对象字面量的语法{key:value}来表示对象。这个返回的对象中含有对内部函数而不是内部数据变量的引用。这样内部的数据还是处于隐藏的状态。可以将这个对象类型的返回值看作本质上是模块的公共API。（一个很好的例子就是jquery）

所以模块模式需要两个必要的条件：

1、必须有外部的封闭函数（CoolModule），该函数必须至少被调用一次（每次创建一个新的模块的时候，都会创建一个新的模块实例）
2、封闭函数至少要返回一个内部函数，这样内部函数才能在私有作用域中形成闭包。
注意：
模块也是普通的函数，因此可以接收参数

 function CoolModule(id) {
       function identify() {
           console.log(id);
       }
        return {
            identify:identify
        }
    }
    var cc1=new CoolModule('sa');   
    cc1.identify();   //sa
    var cc2=new CoolModule('ffdfd');
    cc2.identify();  //ffdfd

模块模式的另一个强大的用法：

命名将要作为公共API返回的对象

function CoolModule(id) {
        function change() {
            PublicAPI.identify=identify2
        }
        function identify1() {
            console.log(id);
        }
       function identify2() {
           console.log(id.toUpperCase());
       }
        var PublicAPI={    //命名将要作为公共API返回的对象
            identify:identify1,
            change:change
        }
        return PublicAPI;
    }
    var cc=new CoolModule("sasas");
    cc.identify();    //sasas
  cc.change();
    cc.identify();   //SASAS

也就是给模块的返回值起了一个名字，这样的话就可以修改。

现代模块机制

 var Mymodules=(function Manager() {
        var modules={};
        function define(name,deps,impl) {  //deps为依赖的模块
            for(var i=0;i<deps.length;i++){
                   deps[i]=modules[deps[i]];
            }
            modules[name]=impl.apply(impl,deps);
        }
        function get(name) {
            return modules[name];
        }
        return {
            define:define,
            get:get
        }
    })();
    Mymodules.define("bar",[],function () {
        function hello(who) {
            return "Let me introduce   " +who;
        }
        return {hello:hello};
    });
    Mymodules.define("test",[],function () {
        function testConsole() {
            return "we are testing";
        }
        return {testConsole:testConsole};
    });
    Mymodules.define("foo",["bar","test"],function (bar) {
        function awesome() {
            var cc="dsdasa";
              console.log(test.testConsole().toUpperCase())
              console.log(bar.hello("cc").toUpperCase())
        }
        return {
            awesome:awesome
        }
    });
    var test=Mymodules.get("test");
    var bar=Mymodules.get("bar");
    var foo=Mymodules.get("foo");
    foo.awesome();
    console.log(bar.hello("hippo"));
    console.log(2121);

块作用域的替代方案

在ES3发布以来，js中就有了块作用域，with和catch语句就是块作用域的两个例子，但是随着ES6的let语句的引入，我们的代码终于有了创建完整、不受约束的块作用域的能力。

   {
        let a=3;
        console.log(a);   //3
    }
    console.log(a);  //a is not defined

let让程序形成了一个块级作用域。

   {
        var a=3;
        console.log(a);   //3
    }
    console.log(a);  // 3

var 就不可以形成一个块级作用域。
以上是ES6解决块级作用域的方案，但是在ES6之前怎样解决块级作用域？

 try{
        throw 2;
    }catch (a){
        console.log(a);  //2
    }
    console.log(a);// a is not defined

总结

当函数可以记住并访问所在的此法作用域，即使函数在当前的词法作用域外执行，这时就产生了闭包。