闭包,原型与原型链

什么是闭包？

首先来简述什么是闭包

<script>

var local="变量"

function fool(){

console.log(local)

}

</script>

假设上面三行代码在一个立即执行函数中（为简明起见，我就不写立即执行函数了，影响理解）。

三行代码中，有一个局部变量 local，有一个函数 foo，foo 里面可以访问到 local 变量。好了这就是一个闭包.

「函数」和「函数内部能访问到的变量」的总和，就是一个闭包。

有的人认为闭包是需要函数套函数，然后 return 一个函数的。

比如这样：

function foo(){
  var local = 1;
  function bar(){
    local++;
    return local;
  }
  return bar;
}
var func = foo();
func();

上面代码中确实有闭包，local 变量和 bar 函数就组成了一个闭包（Closure）。

为什么有的人认为闭包是需要函数套函数呢？

是因为需要局部变量，所以才把 local 放在一个函数里，如果不把 local 放在一个函数里，local 就是一个全局变量了，达不到使用闭包的目的——隐藏变量（等会会讲）。

这也是为什么我上面要说「运行在一个立即执行函数中」。

有些人看到「闭包」这个名字，就一定觉得要用什么包起来才行。其实这是翻译问题，闭包的原文是 Closure，跟「包」没有任何关系。

所以函数套函数只是为了造出一个局部变量，跟闭包无关。

为什么要 return bar 呢？

因为如果不 return，你就无法使用这个闭包。把 return bar 改成 window.bar = bar 也是一样的，只要让外面可以访问到这个 bar 函数就行了。

所以 return bar 只是为了 bar 能被使用，也跟闭包无关。

闭包的作用

闭包常常用来「间接访问一个变量」。换句话说，「隐藏一个变量」。

假设我们在做一个游戏，在写其中关于「还剩几条命」的代码。

如果不用闭包，你可以直接用一个全局变量：

window.lives = 30 // 还有三十条命

这样看起来很不妥。万一不小心把这个值改成 -1 了怎么办。所以我们不能让别人「直接访问」这个变量。怎么办呢？

用局部变量。

但是用局部变量别人又访问不到，怎么办呢？

暴露一个访问器（函数），让别人可以「间接访问」。

代码如下：

function(){
  var lives = 50;
  window.奖励一条命 = function(){
    lives += 1;
  }
  window.死一条命 = function(){
    lives -= 1;
  }
}();

那么在其他的 JS 文件，就可以使用 window.奖励一条命() 来涨命，使用 window.死一条命() 来让角色掉一条命。

看到闭包在哪了吗？

var lives = 50; //变量
window.奖励一条命 = function(){
    lives += 1;
} // 函数

「函数」和「函数内部能访问到的变量」

闭包是 JS 函数作用域的副产品。

换句话说，正是由于 JS 的函数内部可以使用函数外部的变量，所以这段代码正好符合了闭包的定义。而不是 JS 故意要使用闭包。

很多编程语言也支持闭包，另外有一些语言则不支持闭包。

只要你懂了 JS 的作用域，你自然而然就懂了闭包，即使你不知道那就是闭包！

关于闭包的谣言

闭包会造成内存泄露？错。

说这话的人根本不知道什么是内存泄露。内存泄露是指你用不到（访问不到）的变量，依然占居着内存空间，不能被再次利用起来。

闭包里面的变量明明就是我们需要的变量（lives），凭什么说是内存泄露？

这个谣言是如何来的？

因为 IE。IE 有 bug，IE 在我们使用完闭包之后，依然回收不了闭包里面引用的变量。

这是 IE 的问题，不是闭包的问题。参见司徒正美的这篇文章【https://www.cnblogs.com/rubylouvre/p/3345294.html】。

一个小经验

编程界崇尚以简洁优雅为美，很多时候

如果你觉得一个概念很复杂，那么很可能是你理解错了。

原型和原型链

原型

原型和原型链是JavaScript进阶重要的概念，尤其在插件开发过程中是不能绕过的知识点.

由一个例子开始说起

看看JavaScript内置对象Array来做一个数字排序得例子

 

var arr1 = [1, 0, 0, 8, 6];
var arr2 = [1, 0, 0, 8, 6, 1, 1];
arr1.sort(function(n1, n2) {
	return n1 - n2;
});

arr2.sort(function(n1, n2) {
	return n1 - n2;
});

console.log(arr1); //[0, 0, 1, 6, 8]
console.log(arr2); //[0, 0, 1, 1, 1, 6, 8]
console.log(arr1 === arr2);//false
console.log(arr1.sort === arr2.sort);//true

本例子定义了2个数组arr1和arr2，并调用sort方法排序，当两个数组排序结束之后，分别输出这俩数组的内容，控制台输出

arr1 ：[0, 0, 1, 6, 8]
arr2 ：[0, 0, 1, 1, 1, 6, 8]

我知道上诉两行输出并不会引起你的好奇和兴趣，所以这里我想让你把注意力集中输出的第3行和第4行。这里用到JavaScript严格相等操作符===来判断arr1数组和arr2数组是否相等。显然的，arr1和arr2是两个不同的数组，数组长度和元素都不一样，所以控制台输出false。第4行是判断arr1对象和arr2对象的函数sort是否是同一函数，结果输出了true。如果你学过面向对象编程语言，如C++/Java你会发现，这俩对象调用的不是实例方法，而是调用了类方法，什么意思呢？意思是数组arr1和数组arr2是俩不同的对象，但却用了公共的方法，类似于Java中的static方法。

那么JavaScript是如何做到的呢？

var arr1 = [1, 0, 0, 8, 6];
var arr2 = [1, 0, 0, 8, 6, 1, 1];
//数组求和方法
arr1.getSum = function() {
	var sum = 0;
	for(var i = 0; i < this.length; i++) {
		sum += this[i];
	}
	return sum;
}
console.log(arr1.getSum()); //输出15
console.log(arr2.getSum());//控制台报错： Uncaught TypeError: arr2.getSum is not a function

这个例子还是定义了2个变量arr1和arr2，我只在arr1上面定义了函数getSum()，正如所期望的，对象arr1已经完成了数组的累和。但是变量arr2却报错，原因很简单，因为你的变量arr2没有getSum()方法，那么有没有解决方案，函数只定义一次，然后提供给不同的变量使用呢？答案是有的。 

var arr1 = [1, 0, 0, 8, 6];
var arr2 = [1, 0, 0, 8, 6, 1, 1];
//将getSum定义为原型方法
Array.prototype.getSum = function() {
	var sum = 0;
	for(var i = 0; i < this.length; i++) {
		sum += this[i];
	}
	return sum;
}
console.log(arr1.getSum()); //控制台输出15
console.log(arr2.getSum()); //控制台输出17

解决方案就是将实例方法定义为原型方法Array.prototype.getSum，然后对象arr1和arr2就可以共享getSum方法了。为了验证一下这俩对象是否调用了同一个方法，我们写测试代码如下：

console.log(arr1 === arr2); //false 
console.log(arr1.getSum === arr2.getSum); //true

通过上面这个例子，我想你大概知道了JavaScript如何声明静态方法了，也知道第一个例子中为什么两个不同如何定义公共方法了，那么这个prototype关键字是什么呢？它有什么用么？

prototype

在传统的 OOP 中，首先定义“类”，此后创建对象实例时，类中定义的所有属性和方法都被复制到实例中。在 JavaScript 中并不如此复制，而是在对象实例和它的构造器之间建立一个链接（它是__proto__属性，是从构造函数的prototype属性派生的），之后通过上溯原型链，在构造器中找到这些属性和方法。

1.每个函数上面都有一个属性(prototype)指向了函数的原型对象(Person.prototype)。

function Person() { } 
console.log(Person.prototype);

即使你只定义了一个空函数，也存在一个prototype的属性。

例子尽管我们什么都不做，但是浏览器已经在内存中创建了两个对象：Person(函数)和Person.prototype，其中，我们称Person为构造函数，因为我们后面要用到这个函数来new对象，Person.prototype称为Person的原型对象，简称原型。

 现在我们给Person构造函数添加属性并使用new方式来创建一个Person()对象，看看浏览器内存发生了什么？

function Person(name, age) {
	this.name = name;
	this.age = age;
}	
Person.prototype.showName = function() {
			return this.name;
}
var p1 = new Person("SpringChang", 22);
console.log(p1.showName());

2.每个实例上面都有一个隐式原型(proto)指向了函数的原型对象，如本例子中的p1对象有一个隐式原型也指向了Person.prototype对象。

 

 如图所示，Person构造函数有一个隐式属性prototype指向了他的原型对象Person.prototype，而p1对象也有一个隐式属性__proto__指向了源性对象Person.prototype，而在原型上面我们定义了showName方法。

3.实例访问属性或者方法的时候，遵循以为原则：

3.1如果实例上面存在，就用实例本身的属性和方法。

3.2如果实例上面不存在，就会顺着__proto__的指向一直往上查找，查找就停止。

 结合图和代码可以看到，原型上面有showName方法，p1对象也有showName方法，那么这时候p1调用的自身的showName方法，所以输出你调用的是p1对象上面的方法。而p2对象没有showName方法，这时候会顺着p2对象的__proto__属性指向的原型找找看没有有没有showName方法，结果找到了，则p2调用的原型上面的方法。如果原型上面也没有对应的方法呢？这时候它会顺着原型的原型去找对应的方法，最终找到Object对象如果还没找到则报undefined，下面我们来验证一下：

console.log(p1.showName === p2.showName); //false
console.log(p2.sex); //undefined

4.每个函数的原型对象上面都有一个constructor属性，指向了构造函数本身。 

console.log(Person.prototype.constructor == Person); //true

 

 由此，我们根据这4条规则绘制成了上述的关系图，这里我们可以看出Person的原型Person.prototype有一个属性constructor又指向Person构造函数本身。

 原型链

上面我们提到，对象在寻找某一属性时，如果自身属性没找到就去他对应的原型对象去找。若在原型上面找到对应的属性则停止，否则继续去原型的原型找对应的属性，这样构成了一条原型链。上一节中Person的原型其实还有一属性__proto__，他指向了上一级Object的原型对象。

console.log(Person.prototype.__proto__ === Object.prototype); //true

这时候来了一个Object对象，它是JavaScript的顶级对象，同样也有自己的原型Object.protoype，这时候Person对象以及它的原型，Object对象已经对应的原型关系如下图所示。

 

 将Object和Person联系起来的关键是Person.prototype的属性__proto__，它指向了Object.prototype，它将两者打通，构成一个链式关系。同时你也看到Object的prototye也指向了Object.prototype，所以console.log(Person.prototype.proto === Object.prototype)输出的额结果是true。

function Person(name, age) {
	this.name = name;
	this.age = age;
}	
Person.prototype.showName = function() {
	return "你调用的原型上面的方法";
}

var p1 = new Person("SpringChang", 22);
var p2 = new Person("优快云ER", 23);
p2.__proto__ = null;

console.log(p1.showName());
console.log(p2.showName());

 现在我们打破了p1对象的原型，它原本指向的是Person的原型，现在我们让他指向null，则控制台会报错。

Uncaught TypeError: p2.showName is not a function

 现在我们再构造另一个对象Animal，然后强制修改p2的原型链，让他指向Animal的原型。

function Person(name, age) {
	this.name = name;
	this.age = age;
}	
Person.prototype.showName = function() {
	return "你调用的原型上面的方法";
}

//定义另一个构造函数
function Aminal() {}

//在Aminal的原型上面定义方法speek方法
Aminal.prototype.showName = function(str) {
	return "我是Aminal的showName";
}

var p1 = new Person("SpringChang", 22);
var p2 = new Person("优快云ER", 23);
p2.__proto__ = Aminal.prototype; //将p2的__proto__指向Aminal的原型

console.log(p1.showName());  //你调用的原型上面的方法
console.log(p2.showName());  //我是Aminal的showName

 

从上面代码可以看到，p2的showName方法调用的Aminal原型上面的showName，而不再是Person原型上面的showName，如果你还对p2的showName是不是真的是Aminal的showName心存疑虑，那么再来验证一下吧。

console.log(p2.showName() === Aminal.prototype.showName()); //true

一般来说，我们不建议手动去修改某个对象的原型，这会破坏掉原来的原型链。但是原型却是JavaScript面向对象编程中相当重要的一个点，因为你可以利用它更好的封装一个类。

1. 每一个构造函数都有一个原型对象
2. 构造函数名称.prototype属性就可以得到构造函数对应的原型对象。
3. 每一个原型对象中有2个属性constructor / __proto__
4. 原型对象的constructor属性是用来得到原型对象对应的构造函数
5. 原型对象的__proto__属性是用来得到原型对象的原型对象。
6. Object.protoype顶级原型对象。
7. 可以通过构造函数创建出实例对象【new  构造函数()】
8. 每一个实例对象都有一个 __proto__属性用来得到创建当前实例对象的构造函数对应的原型对象。