第5章：作用域闭包

到底什么是闭包

• 本章讲解闭包(Closures)，它与作用域工作原理息息相关。

• 首先我用自己总结的三句话，简单说明什么是闭包：

  • （1）首先我们要知道，变量的查找 规则 是由内到外的；

  • （2）所以 子函数可以访问外部作用域 的变量；

  • （3）如果 把子函数赋值给外部变量 时，此时外部变量就 拥有 了可以 访问封闭数据包的能力 ；

• 一个简单的闭包示例

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

• 分析上述代码：

  • bar函数能访问外部foo函数的作用域，将bar传递给外部变量baz来执行；

  • 此时bar函数在原来定义的词法作用域之外执行，同时持有foo函数作用域的引用，这就叫作闭包。

• 并且通过闭包的执行方式，foo函数在执行后，其作用域不会被立即销毁（毕竟bar函数还要用的啊）

闭包暴露的方式不止一种

• 闭包函数除了可以直接赋值给外部变量，也可以通过执行外部函数，将闭包函数以参数传递的方式暴露出去。

var foo(){    var a = 2;    //闭包函数
    function baz(){        console.log(a);; //2
    }    //执行外部函数，将闭包函数通过参数的方式传递进去
    bar(baz)
}var bar(fn){
    fn();
}

闭包是最熟悉的陌生人

• 虽然闭包比较隐晦，但它绝不仅仅是一个好玩的玩具而已，在我们的代码中到处都有它的身影。

• 比如常见的定时函数setTimeout()：

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

上述代码等价于：

//全局的setTimout函数准备就绪var setTimout = function(invokeFn){}function wait(message){    //timer内部函数拥有对mesage的访问权
    var timer = function(){        console.log(message);
    }    //执行setTimeout()函数，并将timer以参数方式传递进去
    setTimout(timer);
}

• 是不是有似曾相似的感觉？内部函数timer()具有外部函数wait()作用域中的message变量的引用，它就是闭包。

• 除了定时函数之外，jQuery代码也普遍的在使用闭包，不信你看下面的代码：

//参数传递一个name字符串，选择器字符串function setupBot(name,selector){    //通过选择器字符串初始化成jQuery对象
    //绑定点击事件
    $(selector).click(function activator(){        //打印外部函数的name
        console.log('Activating:' + name);
    })
}

setupBot('Closure Bot 1','#bot_1');
setupBot('Closure Bot 2','#bot_2');

• 其实无论何时何地，只要将函数当做参数进行传递，就有闭包的应用。

• 什么定时器、事件监听函数、Ajax请求回调函数、跨窗口通信、Web Workers等代码中，都普遍应用到了闭包。

• 它每天与我们擦肩而过，就好像那个最熟悉的陌生人。

闭包解决了什么问题

1. 用闭包造块级作用域

• 我们先看问题： 我只是想依次输出循环的i（1 ~ 5）

for(var i=1;i<=5;i++){
    setTimtou(function timer(){        console.log(i);  
    },0)
}

• 见鬼了，然而输出的结果却是五次6，这是为什么呢？

• 其根本原因是，定时器的回调函数永远在循环结束后才执行。

• 那你可能会想，哦，那我岂不是永远都不能在for循环中用定时器了？JavaScript真垃圾！诶诶，先别慌，我们来分析一下。

• 我们不是预期循环的每个迭代中，都有一个i的副本，然后输出它吗？通过闭包就能实现。

for(var i=1;i<=5;i++){
    (function(index){
        setTimtou(function timer(){            console.log(index);  
        },0)
    })(i);
}

• 我们通过IIFE构造了一个块级作用域将i存了起来。

• 提到块级作用域，其实ES6的语法里还有一种更便捷的解决方式——let声明

for(let i=1;i<=5;i++){
    setTimtou(function timer(){        console.log(i);  
    },0)
}

2. 用闭包造模块

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
    }
}

• 上述代码演示了JavaScript模块暴露。通过调用CoolModule函数创建一个模块实例，CoolModule返回的对象中包含内部函数的引用，就相当于模块的公共API。

• 当然上述代码可以任意调用多次，重复返回新的模块实例，我们可以改成单例模式：

//通过一个IIFE函数来包装var foo = (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
    }
})();

foo.doSomething();  //coolfoo.doAnother();    //1,2,3

• 模块的公共API不仅可以是内部私有变量的访问，也可以是修改私有变量的方法：

var foo = (function CoolModule(id){    var moduleId = id;    function showId(){        console.log(moduleId);
    }    function uppcaseId(){
        moduleId = moduleId.toUpperCase();
    }    return{        showId : showId,        uppcaseId : uppcaseId
    }
})('fooModule');

foo.showId();
foo.uppcaseId();
foo.showId();

• 其实大多数模块管理机制本质是也是通过类似的方式来实现的，我们来尝试写一个简版的模块管理器：

/**
 * 定义牛批哄哄的超级模块管理器
 */var SuperModules = (function(){    //所有的模块集合，以name作为key
    var moduleMap = {};    
    function define(name,deps,impl){        //获取依赖
        for(var i=0;i<deps.length;i++){
            deps[i] = moduleMap[deps[i]]        
        }        //执行引入的模块，并以deps作为参数
        moduleMap[name] = impl.apply(impl,deps);
    }    
    function get(name){
        reutrn moduleMap[name];
    }    
    //暴露公共API
    return{        define : define,        get : get
    }
})()/**
 * 先定义一个bar模块
 * 没有依赖，impl是一个执行函数
 */SuperModules.define('bar',[],function(){    function hello(name){        return 'let me introduce:' + name;
    }    return {        hello : hello
    }
})/**
 * 再定义一个foo模块
 */SuperModules.difine('foo',['bar'],function(bar){    var hungry = 'hippo';    
    function awesome(){        console.log(bar.hello(hungry).toUpperCase());
    }    
    return {        awesome : awesome
    }
})/**
 * 调用测试
 */var bar = SuperModules.get('bar');var foo = SuperModules.get('foo');//let me introduce: hippoconsole.log(bar.hello('hippo'));//let me introduce: HIPPOfoo.awesome();

• 是不是看起来比较复杂……不过不用担心，ES6以及添加了模块的语法支持！

• ES6会将每个js文件当做独立的模块来处理，每个模块可以通过import关键字导入依赖的模块，或者通过export关键字导出API。你需要做的，只是拥抱ES6！

• bar.js

function hello(name){    return 'let me introduce:' + name;
}export hello;

• foo.js

import hello from 'bar';var hungry = 'hippo';function awesome(){    console.log(bar.hello(hungry).toUpperCase());
}export awesome;

• baz.js

module foo from 'foo';module bar from 'bar';//let me introduce: hippoconsole.log(bar.hello('hippo'));//let me introduce: HIPPOfoo.awesome();

小结

• 内部函数可以访问外部函数的作用域，如果将内部函数暴露给外部变量时，或者说内部函数在定义的词法作用域之外执行时，就产生了闭包。

• 闭包是个非常强大的工具，可以用来实现模块模式。

• 模块的特征：

  • 为创建内部作用域而调用一个包装函数；

  • 包装函数的返回值必须至少包含一个对内部函数的引用，这样就会创建涵盖整个包装函数内部作用域的闭包；

作者：梁同学de自言自语
链接：https://www.jianshu.com/p/7741dd5f6485