资讯专栏INFORMATION COLUMN

【JS基础】原型对象的那些事(一)

edgardeng / 1901人阅读

摘要:通过同一个构造函数实例化的多个实例对象具有同一个原型对象。所以当给原型对象赋值一个新对象时,切记将原型对象的指回原构造函数以上就是本次分享的内容,关于原型对象的其他知识,下一篇基础原型对象的那些事二会讲到。

谈起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的实例person1person2各自都有了一个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方法写到了构造函数的原型对象上,而不是写在构造函数里。

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

还记得之前说的吗:

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

person1person2上显然是没有sayName方法的,但是他们的原型对象有啊。

所以这里的person1.sayNameperson2.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]
此处有坑

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

1.

    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]

2.

    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.ageListperson2.ageList也变化了,说明person1.ageListperson2.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基础—原型对象的那些事(二)会讲到。

ps:写的啰啰嗦嗦的,也不知道大家会不会看着烦。。。

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/84900.html

相关文章

  • JS基础原型对象那些(二)

    摘要:只是构造函数上的一个属性,它是一个指针,指向原型对象,并不表示就是原型对象。在上一个例子中,就是一个对象,这个对象可以说是原生构造函数的实例,所以也是一个对象,所以它也有属性,不过它的指向也就是原型链的顶端,再往上就没有了。 上一篇讲了①原型对象是什么;②__proto__、prototype、constructor的关系;③原型对象的作用;④原型对象带来的一些需要注意的问题; 没理解...

    yanbingyun1990 评论0 收藏0
  • 唠叨js对象与哈希表那些

    摘要:的扩展知识对于哈希表来说,最重要的莫过于生成哈希串的哈希算法和处理冲突的策略了。由于链表的查找需要遍历,如果我们将链表换成树或者哈希表结构,那么就能大幅提高冲突元素的查找效率。 最近在整理数据结构和算法相关的知识,小茄专门在github上开了个repo https://github.com/qieguo2016...,后续内容也会更新到这里,欢迎围观加星星! js对象 js中的对象是基...

    Nosee 评论0 收藏0
  • js面向对象浅析--继承那些

    摘要:有需要还可以修改指向谦龙寄生组合式继承思路是通过借用构造函数来继承属性,通过原型链的混合形式来继承方法改变执行环境实现继承有需要还可以修改指向谦龙谦龙拷贝继承该方法思路是将另外一个对象的属性和方法拷贝至另一个对象使用递归 前言 js中实现继承的方式只支持实现继承,即继承实际的方法,而实现继承主要是依靠原型链来完成的。 原型链式继承 该方式实现的本质是重写原型对象,代之以一个新类型的实例...

    molyzzx 评论0 收藏0
  • JavaScript面向对象那些

    摘要:委托上面的代码结合了构造函数和原型两种方式去创建对象,首先聊聊构造函数构造函数构造函数本质上还是函数,只不过为了区分将其首字母大写了而已。注意注释掉的代码是自动执行的,但这并不是构造函数独有的,每个函数在声明时都会自动生成。 首先看看下面两个1+1=2的问题: 问题一:为什么改变length的值,数组的内容会变化? var arr = [1]; arr.length = 3; aler...

    王伟廷 评论0 收藏0
  • jS:关于对象遍历和数组遍历那些

    摘要:如图遍历数组遍历数组元素并以某种方式处理每个元素是一个常见的操作。如图不过,里的功能比较强大,可以遍历而且返回值是的则被省略掉总结遍历对象,遍历出来的是键名,而不是键值,参数必须是对象。 可能是由于职业的关系,下班之后完全不想Open PC,但很多知识点有必要自己做个小小总结。本人之前对原生Array和Object完全没概念。 遍历对象的方法: Object.keys(Object)...

    qingshanli1988 评论0 收藏0

发表评论

0条评论

edgardeng

|高级讲师

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<