JS-14-闭包

一、函数作为返回值

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。

示例：我们来实现一个对Array的求和

function sum(arr) {
    return arr.reduce(function (x, y) {
        return x + y;
    });
}

sum([1, 2, 3, 4, 5]); // 15

但是，如果不需要立刻求和，而是在后面的代码中，根据需要再计算怎么办？

可以不返回求和的结果，而是返回求和的函数！

function lazy_sum(arr) {
    var sum = function () {
        return arr.reduce(function (x, y) {
            return x + y;
        });
    }
    return sum;
}

当我们调用lazy_sum()时，返回的并不是求和结果，而是求和函数：

var f = lazy_sum([1, 2, 3, 4, 5]); // function sum()

调用函数f时，才真正计算求和的结果：

f(); // 15

【注意】：

返回的函数并没有立刻执行，而是直到调用了f()才执行。 

在这个例子中，我们在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力。

闭包就是指：一个函数内部定义的函数（内部函数）可以访问其父级函数（外部函数）的变量，甚至在外部函数执行完毕后，这些变量仍然可以被内部函数访问。

请再注意一点，当我们调用lazy_sum()时，每次调用都会返回一个新的函数，即使传入相同的参数，f1()和f2()的调用结果互不影响。

var f1 = lazy_sum([1, 2, 3, 4, 5]);
var f2 = lazy_sum([1, 2, 3, 4, 5]);
f1 === f2; // false

二、闭包

注意到返回的函数在其定义内部引用了局部变量arr，所以，当一个函数返回了一个函数后，其内部的局部变量还被新函数引用。

示例：

function count() {
    var arr = [];
    for (var i=1; i<=3; i++) {
        arr.push(function () {
            return i * i;
        });//arr数组push的是函数！！！
    }
    return arr;
}

var results = count();
var f1 = results[0];
var f2 = results[1];
var f3 = results[2];

在上面的例子中，每次循环，都创建了一个新的函数，然后，把创建的3个函数都添加到一个Array中返回了。

实际结果是：

f1(); // 16
f2(); // 16
f3(); // 16

全部都是16！原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了4，因此最终结果为16。

返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

 

如果一定要引用循环变量怎么办？

方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变： 

function count() {
    var arr = [];
    for (var i=1; i<=3; i++) {
        arr.push((function (n) {
            return function () {
                return n * n;
            }
        })(i));//用参数n绑定循环变量i的值，i后期的改变不影响参数n
    }
    return arr;
}

var results = count();
var f1 = results[0];
var f2 = results[1];
var f3 = results[2];

f1(); // 1
f2(); // 4
f3(); // 9

2-1、匿名函数 

这里用了一个“创建一个匿名函数并立刻执行”的语法：

(function(param1, param2) {  
    // 函数体，使用 param1 和 param2  
})(value1, value2);
// value1 和 value2 是你传递给匿名函数的参数

理论上讲，创建一个匿名函数并立刻执行可以这么写：

function (x) { return x * x } (3);

 但是由于JavaScript语法解析的问题，会报SyntaxError错误，因此需要用括号把整个函数定义括起来：

(function (x) { return x * x }) (3);

 

说了这么多，难道闭包就是为了返回一个函数然后延迟执行吗？

当然不是！闭包有非常强大的功能。举个栗子：

在面向对象的程序设计语言里，比如Java和C++，要在对象内部封装一个私有变量，可以用private修饰一个成员变量。

在没有class机制，只有函数的语言里，借助闭包，同样可以封装一个私有变量：

(function() {  
    var privateVariable = '这是一个私有变量';  
      
    console.log(privateVariable); // 输出: 这是一个私有变量  
})();  
  
// 这里无法访问 privateVariable，因为它是上面匿名函数内部的局部变量  
console.log(privateVariable); // 报错: privateVariable is not defined

 我们用JavaScript创建一个计数器：

function create_counter(initial) {
    var x = initial || 0;
    return {
        inc: function () {
            x += 1;
            return x;
        }// return了一个对象，对象中的属性inc是一个函数！
    }
}

它用起来像这样：

var c1 = create_counter();
c1.inc(); // 1
c1.inc(); // 2
c1.inc(); // 3

var c2 = create_counter(10);
c2.inc(); // 11
c2.inc(); // 12
c2.inc(); // 13

在返回的对象中，实现了一个闭包，该闭包携带了局部变量x，并且，从外部代码根本无法访问到变量x。

换句话说，闭包就是携带状态的函数，并且它的状态可以完全对外隐藏起来。

2-2、JS中的私有变量和局部变量

在JavaScript中，写在函数体内的局部变量确实是私有的，但这种“私有”的概念与一些其他编程语言（如Java或C++）中的私有变量有所不同。

在JavaScript中，没有语言层面的私有变量关键字（如private），但函数作用域提供了实现私有变量效果的一种方式。

当我们在函数内部声明一个变量（使用var、let或const），这个变量就只在那个函数的作用域内可见。这意味着它不能在函数外部被直接访问。这种局部变量在函数外部是不可见的特性，可以看作是实现了私有变量的效果。

function myFunction() {  
    var privateVariable = '这是一个私有变量'; // 局部变量，只在myFunction内可见  
      
    console.log(privateVariable); // 输出: 这是一个私有变量  
}  
  
myFunction(); // 当调用myFunction时，privateVariable是可用的  
console.log(privateVariable); // 报错: privateVariable is not defined（在函数外部不可见）

然而，需要注意的是，JavaScript中的“私有”并不是绝对的。如果有其他方式可以获得对内部变量的引用，那么这些变量仍然可以被外部代码间接访问。

此外，JavaScript的开发者工具通常允许你检查对象的属性和函数的作用域，这也可能暴露看似“私有”的变量。

因此，虽然函数作用域确实提供了一种模拟私有变量的方式，但在JavaScript中并不存在真正的语言级别的私有变量。对于需要更强封装和隐私保护的场景，开发者可能会使用设计模式（如模块模式或闭包）来增强变量的私有性。