当函数作为参数传入函数，该函数为高阶函数，当函数作为函数的返回结果返回，就形成了闭包。返回的函数被引用，该引用就保留了定义时的词法作用域，即该引用就是闭包。

1.函数作为返回值

        'use strict'
        function foo () {
            var attr = [];
            for(var i = 0; i < 10; i++){
                attr.push(function(){
                    return i;
                });
            }
            return attr;
        }
        var r = foo();
        console.log(r[0]()); //10
        console.log(r[1]()); //10
        console.log(r[2]());  //10

改造1：

       'use strict'
        function foo () {
            var attr = [];
            for(let i = 0; i < 10; i++){
                attr.push(function(){
                    return i;
                });
            }
            return attr;
        }
        var r = foo();
        console.log(r[0]()); //0
        console.log(r[1]()); //1
        console.log(r[2]());  //2

改造2：

        'use strict'
        function foo () {
            var attr = [];
            for(var i = 0; i < 10; i++){
                attr.push(function(n){
                    return function(){
                        return n;
                    }
                }(i));
            }
            return attr;
        }
        var r = foo();
        console.log(r[0]());
        console.log(r[1]());
        console.log(r[2]());  

2.返回对象携带闭包

        'use strict';

        function create_counter(initial) {
            var x = initial || 0;
            return {
                inc: function () {
                    x += 1;
                    return x;
                }
            }
        }
        var c1 = create_counter();
        c1.inc(); // 1
        c1.inc(); // 2
        c1.inc(); // 3

注意：对象中产生闭包，对象返回