对象的委托机制浅析

2017-06-01 本文已影响0人 BIGHAI

先看一个简短的例子：

function Foo(){}
Foo.prototype = {}
var obj = new Foo()
obj.constructor === Foo//false
obj.constructor === Object//true

分析：问题——为什么不是Undefined？我们知道对于构造函数new出来的对象来说，他的[[Prototype]]是指向构造函数的prototype对象的。当在一个实例化出来的对象中利用.操作符找不到某个属性的时候，JavaScript引擎就会顺着对象的原型链往上找，对于这里的例子，也就是找到了Foo.prototype对象上，很遗憾由于Foo.prototype被重写，所以此时仍旧找不到constructor属性，所以一开始我觉得的答案是Undefined。然而还是想简单了，对于对象的委托机制来说，JavaScript引擎在查找属性名的时候是不会轻易的就地放弃的，他会继续打破砂锅问到底，既然Foo.prototype对象没有的话，那么便继续沿着到Foo.prototype对象上的[[Prototype]]找，直到找到了Object.prototype为止，所以对于这里的这个例子来说，JavaScript引擎就是找到了Object.prototype上，此时就找到了Object.prototype对象上的constructor属性，其值指向Object函数，所以为Object。

需要指出的是，函数prototype对象上的constructor属性的值是可修改的，但是默认是不可被遍历，所以说当你修改prototype对象上的constructor属性的时候，最好将其访问器属性总enumerable的值改为false。

需要注意的是：利用for...in...获取对象的键名时，原型链上的可被遍历属性也会被涉及。要获取一个对象上属于自己的属性的话，应该使用这两个方法更合适：Object.keys(targetObj)和Object.getOwnPropertyNames(targetObj)，其中前者返回对象自身的可遍历的所有属性，后者返回属于对象自身的所有属性，包括可遍历属性。

function Foo(){}
Foo.prototype.a = 1
Foo.prototype.b = 2
var obj = new Foo()
Object.defineProperty(obj, "c", {
  "value": 3,
  "writable": false,
  "configurable": false,
  "enumerable": false
})
for(var key in obj){
  console.log(key)//a b
}
console.log(Object.keys(obj))//[]
console.log(Object.getOwnPropertyNames(obj))//["c"]

1.原型继承或称之为原型委托
在ES5中，如果你想实现其他语言中的那种继承效果的话，那么使用原型委托可以做到这一点。利用原型委托实现继承的思想是：构造函数实例化出来的对象的[[Prototype]]属性会指向构造函数的prototype对象，而如果我让由A构造函数实例化出来的A对象的[[Prototype]]属性指向B构造函数的prototype的话，那么A对象就能够访问的到B构造函数prototype对象中的属性，正是实现了这样一种复用效果，使得继承可被实现。那么问题来了，怎么让A对象的[[prototype]]指向B构造函数的prototype呢？我们知道A对象的[[Prototype]]是指向A.prototype，而要达到我们希望的效果的话：可以有下面几种方法

利用Object.create(source)：（浅拷贝）这个方法将会返回一个新对象，这个返回的新对象的[[Prototype]]将会指向source，所以source能访问的到的，新对象都能够访问到，这意味着一个庞大的原型链。在这里即A.prototype = Object.create(B.prototype)，这种方法是最为推荐的，副作用最小。需要注意的地方，通过这种方法实现的时候，我们希望被复用的功能并不是挂载在构造函数的prototype对象上，而是挂载在构造函数的prototype对象上的[[Prototype]]中。对应这里的这个例子就是并非挂载在Foo.prototype上，而是Foo.prototype对象的[[Prototype]]对象中。由此带来的是一系列关系复杂，纵横交错的原型链，看了简直让人束手无策。下面看一下这个例子：

function Fun(str){this.name = str}
var obj = {
    "a": 1,
    "test": function(){console.log("success\t" + this.a)}
}
Fun.prototype = Object.create(obj)
Fun.prototype.sayName = function(){console.log(this.name)}
function Foo(str, age){
   Fun.call(this, str)
   this.age = age
   this.a = 666
}
Foo.prototype = Object.create(Fun.prototype)
Foo.prototype.sayAge = function(){console.log(this.age)}
var person = new Foo("hahahai", 21)
person.sayName()//继承而来的 "hahahai"
person.sayAge()//21
console.log(Foo.prototype.hasOwnProperty("sayName"))//false
var _pro = Object.getPrototypeOf(Foo.prototype)
console.log(_pro.hasOwnProperty("sayName"))//true
person.test()//success 666

这里我们解析一下，为什么person.test()不是TypeError而是能够被成功访问。首先对于JavaScript引擎来说，他大概是这样寻找test的：1.person对象自身里寻找；2.无果，person的[[Prototype]]即Foo.prototype上寻找，在它它上面只有sayAge这一个属性；3.无果，到Foo.prototype对象的[[Prototype]]上寻找，它指向Fun.prototype，所以即是到Fun.prototype对象自身上寻找，它上面只有sayName这一个属性；4.无果，所以到Fun.prototype对象的[[Prototype]]上寻找，它指向obj对象上，所以即到obj对象上进行查找，此时成功查找到。
解析二：通过重重难关最终成功访问到了test()函数之后，为什么输出的却是666，这就和我们之前讨论的关于this的访问机制有关了，由于test函数作为对象方法被调用，所以test方法中的this环境对象既是person对象。拓展：有的时候是这样的形式的话：obja.objb.fun()，那么此时fun函数内部this的环境对象又是谁呢？答案就是objb。

简单的浅拷贝：A.prototype = B.prototype，这种方式的缺点很明显，那就是这里是直接让A.prototype和B.prototye指向同一块内存，即浅拷贝。尽管利用target = Object.create(source)也是一种浅拷贝，但是这里的浅拷贝是target的[[Prototype]]和source之间的浅拷贝，所以对target动态添加属性是不会影响source的。但是对于A.prototype = B.prototype那可就不一样了，如果你对对象A动态增加属性的话，那么也会影响B对象。

function Foo(str){this.name = str}
Foo.prototype.sayName = function(){console.log(this.name)}
function Fun(str, age){
    Foo.call(this, str)
    this.age = age
}
Fun.prototype = Foo.prototype
Fun.prototype.sayAge = function(){console.log(this.age)}
var person = new Fun("hahahai", 21)
var person2 = new Foo("AHH")
person.sayName()//"hahahai"
person.sayAge()//21
person2.sayName()//"AHH"
person2.sayAge()//undefined

A.prototype = new B()：缺点就是副作用太明显了，因为我们调用了B构造函数去实例化一个对象出来，而这个对象有很多东西显然是没有必要被继承的。下面可以看一个例子：

function Foo(str){this.name = str}
Foo.prototype.sayName = function(){console.log(this.name)}
function Fun(str, age){
    Foo.call(this, str)
    this.age = age
}
Fun.prototype = new Foo("lili")
Fun.prototype.sayAge = function(){console.log(this.age)}
var person = new Fun("hahahai", 21)
person.sayName()//”hahahai"
person.sayAge()//21
console.log(Fun.prototype.name)//"lili"

利用ES6推出的Object.setPrototypeOf(targetPrototype, sourcePrototype)，下面可以看一个例子：

function Fun(name){this.name = name}
Fun.prototype.sayName = function(){console.log(this.name)}
function Foo(name, age){
    this.name = name
    this.age = age
}
Object.setPrototypeOf(Foo.prototype, Fun.prototype)
console.log(Foo.prototype === Fun.prototype)//false
console.log(Foo.prototype == Fun.prototype)//false
console.log(Object.getOwnPropertyNames(Foo.prototype))//["constructor"]
console.log(Object.getOwnPropertyNames(Fun.prototype))//["constructor", "sayName"]
console.log(Object.getOwnPropertyNames(Object.getPrototypeOf(Foo.prototype)))//["constructor", "sayName"]
var person = new Foo("hahahai", 21)
person.sayName()

通过上面的那个例子我们也可以发现Object.setPrototypeOf(target, source)和target = Object.create(source)是类似的，都是利用target.prototype对象的[[Prototype]]引用source.prototype。既然新标准有个专门的函数来实现原型的委托的话，那么我推荐使用Object.setPrototypeOf(targetPrototype, sourcePrototype)。

END

对象的委托机制浅析

猜你喜欢

热点阅读