作用域与闭包（2）

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

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

基于词法作用域的查找规则（RHS引用查询），函数bar（）可以访问外部foo（）作用域中的变量a。然后我们将bar（）函数本身当作一个值类型进行传递。在foo（）执行后，其返回值，实际上只是通过不同的标识符引用调用了内部函数bar（）。

因为bar（）是在自己定义的词法作用域以外的地方执行，bar（）拥有涵盖foo（）内部作用域的闭包。所以foo（）执行后其内部作用域不会被销毁。

function wait(message)
{
    setTimeout(function timer()
    {
        console.log(message);
    }, 1000);
}
wait("hello, closure!");

将一个内部函数（timer）传递给setTimeout()。timer具有涵盖wait（）作用域的闭包，因此还保有对变量message的引用。深入到引擎的内部原理中，内置的工具函数setTimeout（）持有对一个参数的引用。引擎会调用这个函数（timer），而词法作用域在这个过程中保持完整——闭包。

2、循环和闭包

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

我们期待这段代码行为是分别输出数字1~5，每秒一次，每次一个。但实际上，输出的是以每秒一次的频率输出五次6。我们试图假设循环中的每个迭代在运行时会给自己捕获一个i的副本。但根据作用域的工作原理，实际情况是尽管循环中的五个函数是在各个迭代中分别定义的，但是它们都被封闭在一个共享的全局作用域中，因此只有一个i。
用IIFE解决：

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

用块作用域解决：
使用IIFE在每次迭代时都创建一个新的作用域。也就说每次迭代需要一个块作用域。

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

块作用域本质上是将一个块转换成一个可以被关闭的作用域。

3、模块

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

首先，CoolModule（）只是一个函数，必须要通过它来创建一个模块实例，其次，CoolModule（）返回一个用对象字面量语法{key：value}来表示的对象。这个返回的对象中含有对内部函数而不是内部数据变量的引用。保持内部数据变量是隐藏私有的状态。可以将这个对象类型的返回值看作本质上是模块的公共API。
模块模式需要具备两个必要条件：

1. 必须有外部的封闭函数，该函数必须至少被调用一次（每次调用都会创建一个新的模块实例）
2. 封闭函数必须返回至少一个内部函数，这样内部函数才能在私有作用域中形成闭包，并且可以访问或者修改私有的状态。

现代的模块机制

var MyModules = (function Manager(){
    var modules = {};
    function define(name, deps, impl){
        for (var i = 0; i < deps.length; i++){
            deps[i] = modules[deps[i]];
        }
        modules[name] = impl.apple(impl, deps);
    }
    function get(name){
        return modules[name];
    }
    return{
        define : define,
        get : get
    }
})();

这段代码的核心是modulus[name] = impl.apply(impl,deps)。为了模块的定义引入了包装函数，并且将返回值存储在一个根据名字来管理的模块列表中。

MyModules.define("bar", [], function (){
    function hello(who){
        return "Let me introduce: " + who;
    }
    return{
        hello : hello
    };
});
MyModules.define("foo", ["bar"], function (bar){
    var hungry = "hippo";
    function awesome(){
        console.log(bar.hello(hungry).toUpperCase());
    }
    return{
        awesome : awesome
    };
});
var bar = MyModules.get("bar");
var foo = MyModules.get("foo");
console.log(bar.hello("hippo")); // Let me introduce: hippo
foo.awesome(); // LET ME INTRODUCE: HIPPO

foo和bar模块都是通过一个返回公共API的函数来定义的。foo甚至接受bar的示例作为依赖参数，并能相应地使用它。