HTML5学习笔记（十八）：闭包

高阶函数

JavaScript的函数其实都指向某个变量。既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，也可以返回一个函数，这种函数就称之为高阶函数。

函数作为参数

示例如下：

 function absAdd(x, y, f) {
     return f(x) + f(y);
 }
 console.log(absAdd(-1, 2, Math.abs)); //

函数作为参数的好处是我们可以通过修改参数就可以改变函数的行为。

函数作为返回值

示例如下：

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

 var f1 = arrSum([1, 2, 3, 4, 5]);
 var f2 = arrSum([2, 4, 6, 8, 10]);

 console.log(f1 === f2); // false

 console.log(f1()); //
 console.log(f2()); //

每次调用arrSum方法返回的都是一个新创建的函数，所以判断是不相等的。

返回函数时，可以决定在何时执行该函数。

闭包

我们注意到上面例子里返回的函数在其定义内部引用了局部变量arr，所以，当一个函数返回了一个函数后，其内部的局部变量还被新函数引用，这种情况就称为闭包。

我们看下一个例子：

 function foo() {
     var r = [];
     for (var i = 0; i < 3; i++) {
         r[i] = function() {
             return i;
         };
     }
     return r;
 }

 var arr = foo();
 for (var i = 0; i < 3; i++) {
     console.log( arr[i]() );
 }

 //
 //
 //

我们希望打印0,1,2这几个数字，但是实际上打印的都是3，这是由于返回的函数保存的是变量i，实际上在循环之后变量i就变成了3，所以会出现这样的情况。

立即执行函数

那么如何才能打印出0,1,2这几个数字呢，这里需要用到立即执行函数，立即执行函数的意思是在定义好函数之后立即执行，一般这样的函数都是匿名函数。

格式如下：

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

即用一个括号将函数包含，后面紧跟另一个括号进行调用，同时可以进行参数传递。

我们再看下面的例子：

 function foo() {
     var r = [];
     for (var i = 0; i < 3; i++) {
         r[i] = (function(index) {
             return function() {
                 return index;
             };
         })(i);
     }
     return r;
 }

 var arr = foo();
 for (var i = 0; i < 3; i++) {
     console.log( arr[i]() );
 }

 //
 //
 //

我们来看看这个例子，每个闭包函数实际上引用的是index参数，而index参数是在立即执行函数执行时传入的i，所以不存在改变的情况，就可以打印出对应的索引值了。

关于this对象

我们来看下面的例子：

 var name = "Window";

 var obj = {
     name: "Object",
     func: function() {
         return function() {
             return this.name;
         };
     }
 };

 console.log( obj.func()() ); // Window

 var f = obj.func();
 console.log( f() ); // Window

我们发现返回的是全局的name属性，而不是我们期望的obj的name属性。

我们知道每个函数在调用时都会获得this及arguments两个参数，而this参数指向调用该方法的对象。

所以我们可以看一下第14和15行，调用obj.func时this是指向obj对象的，返回的函数实际上被绑定到全局对象上了，所以当调用f函数时，实际上是window进行调用的，所以拿到的name就是window.name。

解决方法如下：

 var name = "Window";

 var obj = {
     name: "Object",
     func: function() {
         var that = this;
         return function() {
             return that.name;
         };
     }
 };

 console.log( obj.func()() ); // Object

 var f = obj.func();
 console.log( f() ); // Object

利用了闭包会持有调用链上的变量的原理即可。

私有属性

在JavaScript中，没有私有属性的概念，所有属性都是公开的。

但是有私有变量的概念，在函数中声明的变量，都是该函数私有的，函数以外的地方不能访问。

我们利用闭包和私有变量的特性可以创建出类似于私有属性的变量。

 function Person(name) {
     // 私有变量
     var age = 0;
     // 私有函数
     function foo() {
         console.log("call private function!");
     }

     this.setName = function(value) {
         name = value;
         foo();
     };
     this.getName = function() {
         return name;
     };

     this.setAge = function(value) {
         age = value;
         foo();
     };
     this.getAge = function() {
         return age;
     };
 }

 var p = new Person("Li Lei");
 p.age = 28;
 console.log(p.getAge()); //
 p.setAge(30);
 console.log(p.getAge()); //
 console.log(p.age); //

我们会发现，在函数内部是直接使用age来访问私有变量的，而如果是this.age则表示当前对象的age公开属性，所以p.age和p.getAge会取得不同的数值。外部是无法访问到内部变量age和参数name的。

使用立即执行函数创建

我们发现上面的方法只能将所有代码都写在构造函数中才能访问到私有变量，其实还有一种写法：

 (function(){
     // 使用 var 定义的变量外部无法访问
     var _name;
     var age = 0;
     // 定义的函数外部无法访问
     function foo() {
         console.log("call private function!");
     }

     // 不使用 var 定义的对象外部可访问
     Person = function(name) {
         _name = name;
     }

     Person.prototype.setName = function(value) {
         _name = value;
         foo();
     }
     Person.prototype.getName = function() {
         return _name;
     }

     Person.prototype.setAge = function(value) {
         age = value;
         foo();
     }
     Person.prototype.getAge = function() {
         return age;
     }
 })();

 var p = new Person("Li Lei");
 p.age = 28;
 console.log(p.getAge()); //
 p.setAge(30);
 console.log(p.getAge()); //
 console.log(p.age); //

通过一个立即执行的匿名函数来包裹即可实现。

模块模式

模块模式可以实现对象的私有属性和方法，如下：

 var instance = function(){
     var name = "Han Meimei";

     function foo(){
         console.log("call private function");
     }

     return {
         setName: function(value) {
             name = value;
             foo();
         },
         getName: function() {
             return name;
         }
     };
 }();

 instance.name = "Li Lei";
 console.log(instance.getName()); // Han Meimei
 instance.setName("Uncle Wang");
 console.log(instance.getName()); // Uncle Wang
 console.log(instance.name); // Li Lei

当然，如果需要创建指定类型的实例，可以使用下面的代码：

 var instance = function(){
     var name = "Han Meimei";

     function foo(){
         console.log("call private function");
     }

     // 这里可以创建指定类型的实例
     var obj = new Object();

     // 添加方法
     obj.setName = function(value) {
         name = value;
         foo();
     };
     obj.getName = function() {
         return name;
     };

     return obj;
 }();

 instance.name = "Li Lei";
 console.log(instance.getName()); // Han Meimei
 instance.setName("Uncle Wang");
 console.log(instance.getName()); // Uncle Wang
 console.log(instance.name); // Li Lei