作用域闭包

一、定义

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

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

函数bar()的词法作用域能访问foo()的内部作用域。然后我们将bar()函数本身当做一个值进行传递。在foo()执行后，通常会期待foo()的整个内部作用域被销毁，但是由于闭包的存在，阻止了内存回收。使得foo(）的作用域能够一直存活，以供bar(）在之后任何时间进行引用。

再看下面的例子：

function foo() {
var a = 2;
function baz() {
console.log( a ); // 2
}
bar( baz );
}
function bar(fn) {
fn(); // 妈妈快看呀，这就是闭包！
}

把内部函数 baz 传递给 bar ，当调用这个内部函数时（现在叫作 fn ） ，它涵盖的 foo() 内部作用域的闭包就可以观察到了，因为它能够访问 a 。

闭包的应用十分广泛，比如在回调函数中：

function wait(message) {
setTimeout( function timer() {
console.log( message );
}, 1000 );
}

function setupBot(name, selector) {
$( selector ).click( function activator() {
console.log( "Activating: " + name );
} );
}

如果将函数（访问它们各自的词法作用域）当作第一级的值类型并到处传递，你就会看到闭包在这些函数中的应用。在定时器、事件监听器Ajax 请求、跨窗口通信、Web Workers 或者任何其他的异步（或者同步）任务中，只要使用了回调函数，实际上就是在使用闭包！
我们还可以利用闭包实现模块模式如下：

var myModules = (function(){
    var modules = {};
    function define(name,deps,impl){
    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('a',[],function(){
    function hello(who){
    return 'hello '+who;
}
return {
    hello:hello
}
})
myModules.define('b',['a'],function(a){
    var name = 'world'
    function awesome(){
    console.log(a.hello(name ))
}
return {
    awesome:awesome
}

var test = myModules.get('b');
test.awesome();//hello world