摘抄自 https://segmentfault.com/a/1190000010842024

拓展理解：https://github.com/mqyqingfeng/Blog/issues/2

概念理解

什么是原型对象呢？有以下几点
1.构造函数有一个 prototype 属性，指向构造函数的原型对象。而实例有一个 __proto__ 属性，也指向原型对象。

根据 MDN https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype 解释 Object.prototype 属性表示 Object 的原型对象。
······
PS：准确的说，实例指向原型对象的是 [[Prototype]] 属性，但这是一个隐式属性，脚本不可访问。因此浏览器厂商提供了一个属性 __proto__ ，用来显式指向原型对象，但它并不是ECMA规范。

注意函数的是 prototype 属性，实例的是 __proto__ 属性，不要弄错

1
2
3

function Person (name) {
    this.name = name
}

这里有一个构造函数 Person，这时，我们创建一个 Person 的实例 person

1	var person = new Person("张三")

按照上边的理论，就可以表示为：Person.prototype === person.__proto__，他们指向的都是原型对象

2.通过同一个构造函数实例化的多个实例对象具有同一个原型对象。

1
2

var person1 = new Person("张三");
var person2 = new Person("李四");

person1.__proto__、person2.__proto__、Person.prototype他们是两两相等的。

3.原型对象有一个constructor属性，指向该原型对象对应的构造函数。

1
2

Person.prototype.constructor === Person
person.__proto__.constructor === Person

4.实例对象本身并没有constructor属性，但它可以继承原型对象的constructor属性。

1
2

person1.constructor === Person
person2.constructor === Person

作用

还是以构造函数Person为例，稍微改一下

1
2
3
4
5
6
7
8

function Person(name){
    this.name = name;
    this.sayName = function(){
        console.log(this.name)
    }
}
var person1 = new Person("张三")
var person2 = new Person("李四")

我们在构造函数Person中增加了一个方法sayName，这样Person的实例person1、person2就各自都有了一个sayName方法。
注意，我说的是各自，什么意思呢？就是说每次创建一个实例，就要在内存中创建一个sayName方法，这些sayName并不是同一个sayName。

1

person1.sayName === person2.sayName // false

多个实例重复创建相同的方法，这显然是浪费资源的。这个时候，我们的原型对象登场了。假如构造函数中的方法我们这样写：

1
2
3
4
5
6
7
8

function Person (name) {
    this.name = name
}
Person.prototype.sayName = function(){
    console.log(this.name)
}
var person1 = new Person("张三")
var person2 = new Person("李四")

和之前的区别是，我们将sayName方法写到了构造函数的原型对象上，而不是写在构造函数里。

这里要先提一个概念，就是当对象找属性或者方法时，先在自己身上找，找到就调用。在自己身上找不到时，就会去他的原型对象上找。这就是原型链的概念，先点到这，大家知道这件事就可以了。

这里就要回顾之前的知识了：通过同一个构造函数实例化的多个实例对象具有同一个原型对象

---

person1和person2上显然是没有sayName方法的，但是他们的原型对象有啊。

---

所以这里的 person1.sayName 和 person2.sayName，实际上都是继承自他原型对象上的 sayName 方法，既然原型对象是同一个，那sayName方法自然也是同一个了，所以此时：

1

person1.sayName === person2.sayName // true

将需要共享的方法和属性放到原型对象上，实例在调用这些属性和方法时，不用每次都创建，从而节约资源，这就是原型对象的作用。

共享带来的“烦恼”

但是，既然是共享，就有一点问题了，还是Person构造函数，我们再改造下

1
2
3
4
5
6

function Person(name){
    this.name = name
}
Person.prototype.ageList = [12,16,18]
var person1 = new Person("张三")
var person2 = new Person("李四")

这时，我们在person1上做一些操作

1

person1.ageList.push(30)

看一下此时person2.ageList是什么

1

person2.ageList // [12,16,18,30]

有点意思，person2上的ageList也多了30

原因其实还是因为共享

共享不好的地方就是：一个实例对引用类型（数组、对象、函数）的属性进行修改，会导致原型对象上的属性修改（其实修改的就是原型对象上的属性，实例是没有这个属性的），进而导致所有的实例中，这个属性都改了！

---

很显然，大部分时候，我们喜欢共享，可以节约资源。但是不喜欢每一个实例都受影响，要不还创建不同的实例干嘛，用一个不就好了（摊手）。

---

所以，我们需要把那些需要共享的属性和方法，写在原型对象上，而每个实例单独用的、不希望互相影响的属性，就写在构造函数里边。类似这样：

1
2
3
4
5
6
7
8
9

function Person(name) {
    this.name = name
    this.ageList = [12, 16, 18]
}
var person1 = new Person("张三")
var person2 = new Person("李四")
person1.ageList.push(30)
person1.ageList // [12, 16, 18, 30]
person2.ageList // [12, 16, 18]

坑

关于原型对象，还有两个坑，需要和大家说一下。
1.

1
2
3
4
5
6
7
8

function Person(name){
    this.name = name
}
Person.prototype.ageList = [12, 16, 18]
var person1 = new Person("张三")
var person2 = new Person("李四")
person1.ageList.push(30)
person2.ageList // [12, 16, 18, 30]

这里没问题，但是假如把person1.ageList.push(30)改为person1.ageList = [1, 2, 3]，结果会是什么呢？

1

person2.ageList // [12, 16, 18]

这里就奇怪了，明明都是对person1.ageList进行操作，怎么就不一样呢？

---

其实原因在于，person1.ageList = [1, 2, 3]是一个赋值操作。

---

我们说过，person1本身是没有ageList属性的，而赋值操作，会给person1增加自己的ageList属性。既然自己有了，也就不用去原型对象上找了。这个时候，原型对象的ageList其实是没有变化的。而person2没有自己的ageList属性，所以person2.ageList还是继承自原型，就是[12, 16, 18]。

2.

1
2
3
4
5
6
7
8
9
10

function Person(name) {
    this.name = name
}
Person.prototype = {
    ageList: [12, 16, 18]
}
var person1 = new Person("张三")
var person2 = new Person("李四")
person1.ageList.push(30)
person2.ageList // [12, 16, 18, 30]

这里依然没毛病，但是写法上有一个变化：我们不再采用Person.prototype.ageList = [12, 16, 18]的形式赋值，而是给Person.prototype赋值了一个对象，对象中有ageList。

---

这样看貌似没有问题，用起来也都一样：改变person1.ageList，person2.ageList也变化了，说明person1.ageList和person2.ageList还是继承自同一个原型对象。

但是，这里有一个问题，之前我们说过：

实例对象本身并没有constructor属性，但它可以继承原型对象的constructor属性

但是这里

1
2

person1.constructor === Person // false
person2.constructor === Person // false

为什么呢？

因为通过给Person.prototype赋值一个对象，就修改了原型对象的指向，此时原型对象的constructor指向内置构造函数Object了(此时打印Person.prototype.constructor得到Object)，使用Person.prototype.ageList = [12, 16, 18]的形式赋值，就不会造成这样的问题。

---

所以当给原型对象赋值一个新对象时，切记将原型对象的constructor指回原构造函数:

1

Person.prototype.constructor = Person