JavaScript高级程序设计－摘要笔记－4

摘要：思路是，使用原型链对原型属性和方法进行继承，借用构造函数实现对实例属性的继承。注意使用寄生式继承来为对象添加函数，会由于不能做到函数复用而降低效率，这一点与构造函数模式类似。无论什么情况下都会调用两次超类型的构造函数。

说明：

此摘要笔记系列是我最近看《JavaScript高级程序设计(第3版)》随手所记。
里面分条列举了一些我认为重要的、需要记下的、对我有帮助的点，是按照我看的顺序来的。
摘要笔记本身没有系统性，没有全面性可言，写在这里供有一定基础的前端开发者参考交流。
里面的知识点、例子大部分来源于本书，或者延伸出来的，都经过我的测试是对的，但是没办法保证100%正确，如果有人看到错误的地方，希望指出来，谢谢。

function Grandpa () {
  this.name = "Grandpa"
}
Grandpa.prototype.sayName = function () {
  console.log(this.name)
}
function Parent () {
  this.name = "Parent"
}
Parent.prototype = new Grandpa()
Parent.prototype.sayHello = function () {
  console.log("hello")
}
var ming = new Parent()
var li = new Parent()
ming.sayName() // "Parent"
ming.sayHello() // "hello"
ming.sayHello === li.sayHello // true
ming.sayName === li.sayName // true
ming instanceof Parent // true
ming instanceof Grandpa // true
ming.constructor === Parent // false 因为在上面重新了 Parent 的原型，而且没有重新指定 constructor
ming.constructor === Grandpa // true 因为上面没有重写 Grandpa 的原型
ming.__proto__ === Parent.prototype // true
ming.__proto__ === Grandpa.prototype // false
Parent.prototype.__proto__ === Grandpa.prototype // true

两种方法： instanceof 操作符和 isPrototypeOf(),
如上例：

Parent.prototype.isPrototypeOf(ming) // true
Grandpa.prototype.isPrototypeOf(ming) // true
Object.prototype.isPrototypeOf(ming) // true

问题1. 引用类型的继承在多个实例之间会共享，无论是原型中添加的属性还是构造函数中添加的属性。如：

function Grandpa () {
  this.friends = ["ming", "li"]
}
function Parent () {
}
Parent.prototype = new Grandpa()
var ming = new Parent()
var li = new Parent()
ming.friends.push("wang")
console.log(ming.friends) // ["ming", "li", "wang"]
console.log(li.friends) // ["ming", "li", "wang"]
ming.friends === li.friends // true

问题2. 在创建子类型的实例中，不能向超类型的构造函数中传递参数

可以解决引用类型的继承在多个实例之间共享的问题
如：

function Grandpa () {
  this.friends = ["ming", "li"]
}
function Aunt () {
  Grandpa.call(this)
}
var ming = new Aunt()
var li = new Aunt()
ming.friends // ["ming", "li"]
ming.friends.push("wang")
li.friends // ["ming", "li"]
ming.friends // ["ming", "li", "wang"]

如：

function Grandpa (name) {
  this.name = name
}
function Parent (name, age) {
  Grandpa.call(this, name)
  this.age = age
}
var ming = new Parent("ming", 15)
ming.age // 15
ming.name // "ming"

注意：这种情况，为了避免超类型的构造函数(Grandpa)重写子类型(Parnt)的属性，应在调用超类型构造函数后，再添加应该在子类型中定义的属性

问题1. 函数没有复用，占用内存多。
问题2. 超类型原型中定义的方法，对子类型而言是不可见的，结果只能使用构造函数模式。

有时候也叫伪经典继承。思路是，使用原型链对原型属性和方法进行继承，借用构造函数实现对实例属性的继承。
如：

function Grandpa (name) {
  this.name = name
  this.friends = ["li"]
}
Grandpa.prototype.sayName = function () {
  console.log(this.name)
}
function Parent (name, age) {
  Grandpa.call(this, name)
  this.age = age
}
Parent.prototype = new Grandpa()
Parent.prototype.sayAge = function () {
  console.log(this.age)
}
var ming = new Parent("ming", 12)
var wang = new Parent("wang", 15)
ming.name // "ming"
ming.friends // ["li"]
ming.friends.push("zhang")
wang.friends // ["li"]
ming.sayName() // "ming"
ming.sayAge() // 12
ming.sayName === wang.sayName // true
ming.sayAge === wang.sayAge // true
ming instanceof Parent // true
ming instanceof Grandpa // true

function object (o) {
  function F () {}
  F.prototype = o
  return new F()
}

实际上，object() 对传入其中的对象执行了一次浅拷贝。如：

var person = {
  name: "wang",
  friends: ["li"]
}
var person1 = object(person)
person1.name // "wang"
person1.friends // ["li"]
person1.name = "zhang"
person.name // "wang"
var person2 = object(person)
person1.friends.push("yang")
person2.friends // ["li", "yang"]
person2.friends === person.friends // true
person1.friends === person.friends // true

这种原型式继承，必须有一个对象作为另一个对象的基础。把基础对象传入 object() 函数，把得到的对象根据具体需求做修改即可。
但是别忘了所有得到的对象引用类型是共享的。

es5 新增了 Object.create() 方法规范了原型式继承。

这个方法接受两个参数，一个用作新对象的原型对象，一个(可选的)为新对象定义额外属性的对象。
在传入一个参数的情况下， Object.create() 和 object() 的行为相同。
Object.create()的第二个参数与 Object.defineProperties() 的第二个参数格式相同：每个属性都是通过自己的描述符来定义的。
这种方式指定的任何属性都会覆盖原型对象上的同名属性。
如：

var person = {
  name: "wang",
  friends: ["li"]
}
var person1 = Object.create(person, {
  name: {
    value: "zhang"
  },
  friends: {
    value: ["a", "b"]
  }
})
person1.name // "zhang"
person1.friends // ["a", "b"]
person.friends // ["li"]
// 支持 Object.create() 的浏览器有 IE 9+，Firefox 4+, Safari 5+, Opera 912+, Chrome.

寄生式继承是与原型式继承紧密相关的一种思路，和工厂模式类似。如：

function createAnother (original) {
  var clone = object(original)
  clone.sayHi = function () {
    console.log("hi")
  }
  return clone
}
var person = {
  name: "wang",
  friends: ["li"]
}
var person1 = createAnother(person)
person1.friends // ["li"]
person1.sayHi() // "hi"

新的对象person1不仅具有person的所有属性和方法，还有自己的 sayHi() 方法。
示范的 object() 函数不是必须的，任何能够返回新对象的函数都适用于此模式。
注意：使用寄生式继承来为对象添加函数，会由于不能做到函数复用而降低效率，这一点与构造函数模式类似。

无论什么情况下都会调用两次超类型的构造函数。一次是在创建子类型原型的时候，一次是在子类型构造函数内部。
如：

function Grandpa (name) {
  this.name = name
  this.friends = ["ming"]
}
Grandpa.prototype.sayName = function () {
  console.log(this.name)
}
function Parent (name, age) {
  Grandpa.call(this, name)
  this.age = age
}
Parent.prototype = new Grandpa() // 第一次调用超类型的构造函数 Grandpa()，
// 此时原型上有一个friends属性(值是["ming"])和name属性(值undefined,因为没有传参)
Parent.prototype.sayHi = function () {
  console.log("hi")
}
var wang = new Parent("wang", 15) // 第二次调用超类型的构造函数 Grandpa()，在 Parent() 函数内部调用，
// 这一步的操作， Parent 的实例 wang 的属性会覆盖 Parent 的原型上的同名属性 name

基本模式如下：

function inheritPrototype (subType, superType) {
  var prototype = object(superType.prototype)
  prototype.constructor = subType
  subType.prototype = prototype
}
function Grandpa (name) {
  this.name = name
  this.friends = ["ming"]
}
Grandpa.prototype.sayName = function () {
  console.log(this.name)
}
function Parent (name, age) {
  Grandpa.call(this, name)
  this.age = age
}
inheritPrototype(Parent, Grandpa) // 这里没有调用超类型的构造函数 Grandpa() ，但是这里调用了一个函数内部的构造函数
Parent.prototype.sayHi = function () {
  console.log("hi")
}
var li = new Parent("li", 20) // 调用超类型的构造函数 Grandpa()，在 Parent() 函数内部调用

这种模式的好处是只调用一次 Grandpa() 构造函数，因此避免了在 Parent.prototype 上创建不必要的、多余的属性。
作者讲，开发人员普遍认为寄生组合式继承是引用类型最理想的继承范式。

继承部分全部结束