【JS基础】原型对象的那些事（一）

谈起js的基础，绕不过去的坎就是：原型链、做用域链、this（em...好吧，还有闭包），今天总结一下关于原型对象的一些知识，供本身和你们复习。

概念理解

什么是原型对象呢？有如下几点：

1.构造函数有一个prototype属性，指向构造函数的原型对象。而实例有一个__proto__属性，也指向原型对象。

PS: 准确的说，实例指向原型对象的是[[Prototype]]属性，但这是一个隐式属性，脚本不可访问。所以浏览器厂商提供了一个属性__proto__，用来显式指向原型对象，但它并非ECMA规范。

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

举个栗子，咱们有一个构造函数Person:

function Person(name) {
    this.name = name
}
复制代码

这时，咱们建立一个Person的实例person：

var person = new Person("张三")
复制代码

按照上边的理论，就能够表示为：

Person.prototype === person.__proto__

他们指向的都是原型对象。

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

var person1 = new Person("张三")
var person2 = new Person("李四")
复制代码

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

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

Person.prototype.constructor === Person
    person.__proto__.constructor === Person
复制代码

4.实例对象自己并无constructor属性，但它能够继承原型对象的constructor属性。

person1.constructor === Person
    person2.constructor === Person
复制代码

做用

OK，说清楚了什么是原型，就要说一下这玩意是干吗用的，为啥要在构造函数里加这么个东西。

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

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。

person1.sayName === person2.sayName 
    
    -> false
复制代码

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

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方法天然也是同一个了，因此此时：

person1.sayName === person2.sayName   
    
    -> true
复制代码

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

共享带来的“烦恼”

可是，既然是共享，就有一点问题了，仍是Person构造函数，咱们再改造一下。

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

这个时候，咱们在person1上作一些操做：

person1.ageList.push(30)
复制代码

看一下此时person2.ageList是什么：

person2.ageList 
    
    -> [12, 16, 18, 30]
复制代码

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

缘由其实仍是由于共享。

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

很显然，大部分时候，咱们喜欢共享，能够节约资源。可是不喜欢每个实例都受影响，要不还建立不一样的实例干吗，用一个不就行了（摊手）。

因此，咱们须要把那些须要共享的属性和方法，写在原型对象上，而每一个实例单独用的、不但愿互相影响的属性，就写在构造函数里边。相似这样：

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]
复制代码

此处有坑

关于原型对象，还有两个坑，须要和你们说一下。

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]，结果会怎样呢？

person2.ageList 
    
    -> [12, 16, 18]
复制代码

这里就奇怪了，都是对person1.ageList进行操做，怎么就不同呢?

其实缘由在于，person1.ageList = [1, 2, 3]是一个赋值操做。

咱们说过，person1自己是没有ageList属性的，而赋值操做，会给person1增长本身的ageList属性。既然本身有了，也就不用去原型对象上找了。这个时候，原型对象的ageList实际上是没有变化的。而person2没有本身的ageList属性，因此person2.ageList仍是继承自原型，就是[12, 16, 18]。

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属性

可是此时

person1.constructor === Person 
    -> false
    
    person2.constructor === Person 
    -> false
复制代码

为何呢？

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

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

Person.prototype.constructor = Person
复制代码

以上就是本次分享的内容，关于原型对象的其余知识，下一篇JS基础—原型对象的那些事（二）会讲到。