对象是一组属性的无序集合，是一组没有特定顺序的值。对象的每个属性或方法都由一个名称来标识，这个名称映射到一个值，所以可以把对象想象成一张散列表，其中内容就是名/值对。

理解对象

对象有两个创建方式:

let person = new Object();

person.name = "Nicholas";

person.age = 29;

person.job = "Software Engineer";

person.sayName = function() {

console.log(this.name);

};

let person = {

age: 29,

job: "Software Engineer",

sayName() {

console.log(this.name);

}

};

属性的类型

ECMA-262 使用一些内部特性来描述属性的特征。这些特性是由为 JavaScript 实现引擎的规范定义的。因此，开发者不能在 JavaScript 中直接访问这些特性。为了将某个特性标识为内部特性，规范会用两个中括号把特性的名称括起来，比如[[Enumerable]]。

属性分为数据属性和访问器属性：

数据属性：数据属性包含一个保存数据值的位置。值会从这个位置读取，也会写入到这个位置。

[[Configurable]]：表示属性是否可以通过 delete 删除并重新定义，是否可以修改它的特性，以及是否可以把它改为访问器属性。
[[Enumerable]]：表示属性是否可以通过 for-in 循环返回。
[[Writable]]：表示属性的值是否可以被修改。
[[Value]]：包含属性实际的值。

访问器属性：访问器属性不包含数据值。相反，它们包含一个获取（getter）函数和一个设置（setter）函数，不过这两个函数不是必需的。

[[Configurable]]：表示属性是否可以通过 delete 删除并重新定义，是否可以修改它的特性，以及是否可以把它改为访问器属性。
[[Enumerable]]：表示属性是否可以通过 for-in 循环返回。
[[Get]]：获取函数，在读取属性时调用。默认值为 undefined。
[[Set]]：设置函数，在写入属性时调用。默认值为 undefined。

定义多个属性

在一个对象上同时定义多个属性的可能性是非常大的。为此，ECMAScript 提供了 Object.defineProperties()方法。这个方法可以通过多个描述符一次性定义多个属性。它接收两个参数：要为之添加或修改属性的对象和另一个描述符对象，其属性与要添加或修改的属性一一对应。比如：

let book = {};

Object.defineProperties(book, {

year_: {

value: 2017

},

edition: {

value: 1

},

year: {

get() {

return this.year_;

},

set(newValue) {

if (newValue > 2017) {

this.year_ = newValue;

this.edition += newValue - 2017;

}

}

}

});

这段代码在 book 对象上定义了两个数据属性 year_和 edition，还有一个访问器属性 year。最终的对象跟上一节示例中的一样。唯一的区别是所有属性都是同时定义的，并且数据属性的configurable、enumerable 和 writable 特性值都是 false。

读取属性的特性

使用 Object.getOwnPropertyDescriptor()方法可以取得指定属性的属性描述符。这个方法接两个参数：属性所在的对象和要取得其描述符的属性名。返回值是一个对象，对于访问器属性包含configurable、enumerable、get 和 set 属性，对于数据属性包含 configurable、enumerable、writable 和 value 属性。比如：

let book = {};

Object.defineProperties(book, {

year_: {

value: 2017

},

edition: {

value: 1

},

year: {

get: function() {

return this.year_;

},

set: function(newValue){

if (newValue > 2017) {

this.year_ = newValue;

this.edition += newValue - 2017;

}

}

}

});

let descriptor = Object.getOwnPropertyDescriptor(book, "year_");

console.log(descriptor.value); // 2017

console.log(descriptor.configurable); // false

console.log(typeof descriptor.get); // "undefined"

let descriptor = Object.getOwnPropertyDescriptor(book, "year");

console.log(descriptor.value); // undefined

console.log(descriptor.enumerable); // false

console.log(typeof descriptor.get); // "function"

合并对象

ECMAScript 6 专门为合并对象提供了 Object.assign()方法。这个方法接收一个目标对象和一个或多个个源对象作为参数，然后将每个源对象中可枚举（Object.propertyIsEnumerable()返回 true）和自有（Object.hasOwnProperty()返回 true）属性复制到目标对象。以字符串和符号为键的属性会被复制。对每个符合条件的属性，这个方法会使用源对象上的[[Get]]取得属性的值，然后使用目标对象上的[[Set]]设置属性的值。

let dest, src, result;

/**

* 简单复制

*/

dest = {};

src = { id: 'src' };

result = Object.assign(dest, src);

// Object.assign 修改目标对象

// 也会返回修改后的目标对象

console.log(dest === result); // true

console.log(dest !== src); // true

console.log(result); // { id: src }

console.log(dest); // { id: src }

/**

* 多个源对象

*/

dest = {};

result = Object.assign(dest, { a: 'foo' }, { b: 'bar' });

console.log(result); // { a: foo, b: bar }

/**

* 获取函数与设置函数

*/

dest = {

set a(val) {

console.log(`Invoked dest setter with param ${val}`);

}

};

src = {

get a() {

console.log('Invoked src getter');

return 'foo';

}

};

Object.assign(dest, src);

// 调用 src 的获取方法

// 调用 dest 的设置方法并传入参数"foo"

// 因为这里的设置函数不执行赋值操作

// 所以实际上并没有把值转移过来

console.log(dest); // { set a(val) {...} }

Object.assign()实际上对每个源对象执行的是浅复制。如果多个源对象都有相同的属性，则使用最后一个复制的值。此外，从源对象访问器属性取得的值，比如获取函数，会作为一个静态值赋给目标对象。换句话说，不能在两个对象间转移获取函数和设置函数。

对象表示及相等表示

ECMAScript 6 规范新增了 Object.is()，这个方法与===很像，但同时也考虑

到了上述边界情形。这个方法必须接收两个参数：

console.log(Object.is(true, 1)); // false

console.log(Object.is({}, {})); // false

console.log(Object.is("2", 2)); // false

// 正确的 0、-0、+0 相等/不等判定

console.log(Object.is(+0, -0)); // false

console.log(Object.is(+0, 0)); // true

console.log(Object.is(-0, 0)); // false

// 正确的 NaN 相等判定

console.log(Object.is(NaN, NaN)); // true

要检查超过两个值，递归地利用相等性传递即可：

function recursivelyCheckEqual(x, ...rest) {

return Object.is(x, rest[0]) &&

(rest.length < 2 || recursivelyCheckEqual(...rest));

}

增强的对象方法

属性值简写：

let name = 'Matt';

let person = {

};

// 可以简写

let person = {

name

};

可计算属性：

const nameKey = 'name';

const ageKey = 'age';

const jobKey = 'job';

let person = {

[nameKey]: 'Matt',

[ageKey]: 27,

[jobKey]: 'Software engineer'

};

console.log(person); // { name: 'Matt', age: 27, job: 'Software engineer' }

const nameKey = 'name';

const ageKey = 'age';

const jobKey = 'job';

let uniqueToken = 0;

function getUniqueKey(key) {

return `${key}_${uniqueToken++}`;

}

let person = {

[getUniqueKey(nameKey)]: 'Matt',

[getUniqueKey(ageKey)]: 27,

[getUniqueKey(jobKey)]: 'Software engineer'

};

console.log(person); // { name_0: 'Matt', age_1: 27, job_2: 'Software engineer' }

简写方法名：

let person = {

sayName: function(name) {

console.log(`My name is ${name}`);

}

};

//可以简写成

let person = {

sayName(name) {

console.log(`My name is ${name}`);

}

};

// 也可以是

const methodKey = 'sayName';

let person = {

[methodKey](name) {

console.log(`My name is ${name}`);

}

}

person.sayName('Matt'); // My name is Matt

对象解构：

let person = {

age: 27

};

let { name: personName, age: personAge } = person;

console.log(personName); // Matt

console.log(personAge); // 27

可以在解构赋值的同时定义默认值，这适用于前面刚提到的引用的属性不存在于源对象中的

情况：

let person = {

age: 27

};

let { name, job='Software engineer' } = person;

console.log(name); // Matt

console.log(job); // Software engineer

解构并不要求变量必须在解构表达式中声明。不过，如果是给事先声明的变量赋值，则赋值表达式必须包含在一对括号中：

let personName, personAge;

let person = {

age: 27

};

({name: personName, age: personAge} = person);

console.log(personName, personAge); // Matt, 27

创建对象

工厂模式

工厂模式是一种众所周知的设计模式，广泛应用于软件工程领域，用于抽象创建特定对象的过程。

function createPerson(name, age, job) {

let o = new Object();

o.name = name;

o.age = age;

o.job = job;

o.sayName = function() {

console.log(this.name);

};

return o;

}

let person1 = createPerson("Nicholas", 29, "Software Engineer");

let person2 = createPerson("Greg", 27, "Doctor");

这里，函数 createPerson()接收 3 个参数，根据这几个参数构建了一个包含 Person 信息的对象。可以用不同的参数多次调用这个函数，每次都会返回包含 3 个属性和 1 个方法的对象。这种工厂模式虽然可以解决创建多个类似对象的问题，但没有解决对象标识问题（即新创建的对象是什么类型）。

构造函数模式

自定义构造函数，以函数的形式为自己的对象类型定义属性和方法。

function Person(name, age, job){

this.name = name;

this.age = age;

this.job = job;

this.sayName = function() {

console.log(this.name);

};

}

let person1 = new Person("Nicholas", 29, "Software Engineer");

let person2 = new Person("Greg", 27, "Doctor");

person1.sayName(); // Nicholas

person2.sayName(); // Greg

与工厂模式的区别是：

没有显式的创建对象。
属性和方法直接给this。
没有return
函数名首字母大写开头有利于区别普通函数与构造函数。

创建Person实例需要使用new操作符，当我们调用new时会执行如下操作：

在内存中创建一个新对象。
在新对象内部的[[prototype]]特性被赋值为构造函数的prototype属性。
构造函数内部得this被赋值为这个新对象。即this指向新对象
执行构造函数内部代码。给新对象添加属性
如果构造函数返回非空对象，则返回该对象；否则返回刚创建的新对象。

上面例子得person1和person2分别保存Person不同实例，它们得constructor都指向Person。

console.log(person1.constructor == Person); // true

console.log(person2.constructor == Person); // true

console.log(person1 instanceof Object); // true

console.log(person1 instanceof Person); // true

console.log(person2 instanceof Object); // true

console.log(person2 instanceof Person); // true

关于构造函数：

1. 构造函数也是函数

构造函数与普通函数得唯一区别在于调用方式不同。除此之外没有任何区别。任何函数使用new操作符调用就是构造函数，不使用new操作符就是普通函数。如果上述例子中得Person作为函数调用：

Person("Greg", 27, "Doctor"); // 添加到 window 对象

window.sayName(); // "Greg

this会指向window所以属性会被添加到window中。

2.构造函数的问题

构造函数虽有用，但不是没有问题。最主要的问题在于，其定义的方法会在每个实例中创建一遍，上述例子一样，person1和person2都有sayName方法，但是这两个不是同一个Function实例。

function Person(name, age, job){

this.name = name;

this.age = age;

this.job = job;

this.sayName = new Function("console.log(this.name)"); // 逻辑等价

}

console.log(person1.sayName == person2.sayName); // false

都是做一样的事情没必要定义不同的实例，要解决这个问题可以将函数定义到构造函数外边。

function Person(name, age, job){

this.name = name;

this.age = age;

this.job = job;

this.sayName = sayName;

}

function sayName() {

console.log(this.name);

}

let person1 = new Person("Nicholas", 29, "Software Engineer");

let person2 = new Person("Greg", 27, "Doctor");

person1.sayName(); // Nicholas

person2.sayName(); // Greg

在这里sayName属于全局函数，person1和person2都指向全局作用域中的函数。这样虽然解决了创建多个实例的问题，但是会污染全局环境，并且如果有多个方法，那么就要在外部创建多个方法，自定义类型引用代码无法很好地聚在一起。这个问题可以通过原型模式解决。

原型模式

每个函数都会创建prototype属性，这个属性是一个对象，包含应该由特定引用类型的实例共享的属性和方法。实际上，这个对象就是通过调用构造函数创建的对象的原型。使用原型对象的好处是，在它上面定义的属性和方法可以被对象实例共享。原来在构造函数中直接赋给对象实例的值，可以直接赋值给它们的原型。

function Person() {}

Person.prototype.name = "Nicholas";

Person.prototype.age = 29;

Person.prototype.job = "Software Engineer";

Person.prototype.sayName = function() {

console.log(this.name);

};

let person1 = new Person();

person1.sayName(); // "Nicholas"

let person2 = new Person();

person2.sayName(); // "Nicholas"

console.log(person1.sayName == person2.sayName); // true

与构造函数模式不同，使用这种原型模式定义的属性和方法是由所有实例共享的。因此 person1 和 person2 访问的都是相同的属性和相同的 sayName()函数。要理解这个过程，就必须理解 ECMAScript 中原型的本质。

理解原型

无论何时，只要创建一个函数，就会按照特定的规则为这个函数创建一个prototype属性指向原型对象。默认情况下，所有原型对象自动获得一个名为constructor属性，指回与之关联的构造函数。

在自定义构造函数时，原型对象默认只会获得 constructor 属性，其他的所有方法都继承自Object。每次调用构造函数创建一个新实例，这个实例的内部[[Prototype]]指针就会被赋值为构造函数的原型对象。脚本中没有访问这个[[Prototype]]特性的标准方式，但 Firefox、Safari 和 Chrome会在每个对象上暴露__proto__属性，通过这个属性可以访问对象的原型。在其他实现中，这个特性完全被隐藏了。

关键在于理解这一点：实例与构造函数原型之间有直接的联系，但实例与构造函数之间没有。

如图展示了 Person 构造函数、Person 的原型对象和 Person 现有两个实例之间的关系。注意，Person.prototype 指向原型对象，而 Person.prototype.contructor 指回 Person 构造函数。原型对象包含 constructor 属性和其他后来添加的属性。Person 的两个实例 person1 和 person2 都只有一个内部属性指回 Person.prototype，而且两者都与构造函数没有直接联系。另外要注意，虽然这两个实例都没有属性和方法，但 person1.sayName()可以正常调用。这是由于对象属性查找机制的原因。

虽然不是所有实现都暴露了[[Prototype]]，但可以使用isPrototypeOf()来确定两个对象之间的关系：

console.log(Person.prototype.isPrototypeOf(person1)); // true

console.log(Person.prototype.isPrototypeOf(person2)); // true

这里通过原型对象调用 isPrototypeOf()方法检查了 person1 和 person。

一种Object类型方法叫叫 Object.getPrototypeOf()，返回参数的内部特性[[Prototype]]的值：

console.log(Object.getPrototypeOf(person1) == Person.prototype); // true

console.log(Object.getPrototypeOf(person1).name);

还有一种是个 setPrototypeOf()方法，可以向实例的私有特性[[Prototype]]写入一个新值。这样就可以重写一个对象的原型继承关系：

let biped = {

numLegs: 2

};

let person = {

};

Object.setPrototypeOf(person, biped);

console.log(person.name); // Matt

console.log(person.numLegs); // 2

console.log(Object.getPrototypeOf(person) === biped); // true

因为setPrototypeOf()会影响影响性能，可以通过可以通过 Object.create()来创建一个新对象，同时为其指定原型：

let biped = {

numLegs: 2

};

let person = Object.create(biped);

person.name = 'Matt';

console.log(person.name); // Matt

console.log(person.numLegs); // 2

console.log(Object.getPrototypeOf(person) === biped); // true

原型层级

在通过对象访问属性时，会按照这个属性的名字开始搜索。会先从实例本身开始搜，如果实例上发现了给定的名称，则返回该名称对应的值。如果没有找到，则搜索会沿着指针进入原型对象，然后在原型对象上找到该属性后再返回对应的值。这就是原型用于在多个对象实例间共享属性和方法的原理。

注意：虽然可以通过实例读取原型身上的值，但是不能修改。如果在实例上添加了与原型同名的属性，则会返回实例上的属性。

function Person() {}

Person.prototype.name = "Nicholas";

Person.prototype.age = 29;

Person.prototype.job = "Software Engineer";

Person.prototype.sayName = function() {

console.log(this.name);

};

let person1 = new Person();

let person2 = new Person();

person1.name = "Greg";

console.log(person1.name); // "Greg"，来自实例

console.log(person2.name); // "Nicholas"，来自原型

delete person1.name;

console.log(person1.name); // "Nicholas"，来自原型

可以通过hasOwnProperty属性来确定是来自实例还是原型，如果来自实例返回true，反之false：

function Person() {}

Person.prototype.name = "Nicholas";

Person.prototype.age = 29;

Person.prototype.job = "Software Engineer";

Person.prototype.sayName = function() {

console.log(this.name);

};

let person1 = new Person();

let person2 = new Person();

console.log(person1.hasOwnProperty("name")); // false

person1.name = "Greg";

console.log(person1.name); // "Greg"，来自实例

console.log(person1.hasOwnProperty("name")); // true

console.log(person2.name); // "Nicholas"，来自原型

console.log(person2.hasOwnProperty("name")); // false

delete person1.name;

console.log(person1.name); // "Nicholas"，来自原型

console.log(person1.hasOwnProperty("name")); // false

原型和in操作符

有两种方式使用in操作符：单独使用和for-in循环中使用。在单独使用时in操作符会在可以通过对象访问指定对象属性时返回true，无论是在实例还是在原型上：

function Person() {}

Person.prototype.name = "Nicholas";

Person.prototype.age = 29;

Person.prototype.job = "Software Engineer";

Person.prototype.sayName = function() {

console.log(this.name);

};

let person1 = new Person();

let person2 = new Person();

console.log(person1.hasOwnProperty("name")); // false

console.log("name" in person1); // true

!object.hasOwnProperty(name) && (name in object); // 可以知道不在实例上而是在原型上

在 for-in 循环中使用 in 操作符时，可以通过对象访问且可以被枚举的属性都会返回，包括实例属性和原型属性。遮蔽原型中不可枚举（[[Enumerable]]特性被设置为 false）属性的实例属性也会在 for-in 循环中返回，因为默认情况下开发者定义的属性都是可枚举的。

如果想要获取可枚举的实例属性：

Object.keys()
Object.getOwnPropertyNames()

function Person() {}

Person.prototype.name = "Nicholas";

Person.prototype.age = 29;

Person.prototype.job = "Software Engineer";

Person.prototype.sayName = function() {

console.log(this.name);

};

const p = new Person()

p.name = 'awdwa'

console.log(Object.keys(p)) // ['name']

console.log(Object.getOwnPropertyNames(p)) // ['name']

for(let i in p){ // ['name', 'age', 'job', 'sayName']

console.log(i)

}

属性枚举顺序

for-in 循环、Object.keys()、Object.getOwnPropertyNames()、Object.getOwnPropertySymbols()以及 Object.assign()在属性枚举顺序方面有很大区别。for-in 循环和 Object.keys()的枚举顺序是不确定的，取决于 JavaScript 引擎，可能因浏览器而异。Object.getOwnPropertyNames()、Object.getOwnPropertySymbols()和 Object.assign()的枚举顺序是确定性的。先以升序枚举数值键，然后以插入顺序枚举字符串和符号键。在对象字面量中定义的键以它们逗号分隔的顺序插入。

let k1 = Symbol('k1'),

k2 = Symbol('k2');

let o = {

1: 1,

first: 'first',

[k1]: 'sym2',

second: 'second',

0: 0

};

o[k2] = 'sym2';

o[3] = 3;

o.third = 'third';

o[2] = 2;

console.log(Object.getOwnPropertyNames(o));

// ["0", "1", "2", "3", "first", "second", "third"]

console.log(Object.getOwnPropertySymbols(o));

// [Symbol(k1), Symbol(k2)]

对象迭代

可以通过Object.values()和Object.entries()进行迭代，其中values返回值组成的数组，而entries键值对数组。

const o = {

foo: 'bar',

baz: 1,

qux: {}

};

console.log(Object.values(o));

// ["bar", 1, {}]

其他原型方法：缩写

function Person() {}

Person.prototype = {

age: 29,

job: "Software Engineer",

sayName() {

console.log(this.name);

}

};

let friend = new Person();

console.log(friend instanceof Object); // true

console.log(friend instanceof Person); // true

console.log(friend.constructor == Person); // false

console.log(friend.constructor == Object); // true

可以发现这么重写原型后，constructor 不指向原型了而是指向Object了。因为被覆盖了，所以要写成下面这种：

// 第一种

function Person() {

}

Person.prototype = {

constructor: Person, // 保证了这个属性仍然包含恰当的值。

age: 29,

job: "Software Engineer",

sayName() {

console.log(this.name);

}

};

// 第二种

function Person() {}

Person.prototype = {

age: 29,

job: "Software Engineer",

sayName() {

console.log(this.name);

}

};

// 恢复 constructor 属性

Object.defineProperty(Person.prototype, "constructor", {

enumerable: false,

value: Person

});

原型的动态性：就算实例在修改原型之前存在，也会在实例上反映出来。

let friend = new Person();

Person.prototype.sayHi = function() {

console.log("hi");

};

friend.sayHi(); // "hi"，没问题！

原生对象原型

所有的原生对象之所以可以调用它们的方法就是因为它们的原型上实现了这些方法，可以对这些属性进行修改：

String.prototype.startsWith = function (text) {

return this.indexOf(text) === 0;

};

let msg = "Hello world!";

console.log(msg.startsWith("Hello")); // true

但是不推荐，因为这样做很可能造成误会，而且可能引发命名冲突（比如一个名称在某个浏览器实现中不存在，在另一个实现中却存在）。另外还有可能意外重写原生的方法。推荐的做法是创建一个自定义的类，继承原生类型。

原型的问题

它弱化了向构造函数传递参数的能力，并且共享值，导致所有实例都只有相同的属性值。所以一般不会单独使用原型模型。

继承

原型链

ECMAScript的主要继承方式就是原型链，基本思想就是原型继承多个引用类型的属性和方法。

构造函数、原型和实例的关系：每个构造函数都有一个原型对象，原型有一个属性指回构造函数，而实例有一个内部指针指向原型。如果原型是另一个类型的实例呢？那就意味着这个原型本身有一个内部指针指向另一个原型，相应地另一个原型也有一个指针指向另一个构造函数。这样就在实例和原型之间构造了一条原型链。这就是原型链的基本构想

function SuperType() {

this.property = true;

}

SuperType.prototype.getSuperValue = function() {

return this.property;

};

function SubType() {

this.subproperty = false;

}

// 继承 SuperType

SubType.prototype = new SuperType();

SubType.prototype.getSubValue = function () {

return this.subproperty;

};

let instance = new SubType();

console.log(instance.getSuperValue()); // true

默认原型

实际上，原型链中还有一环。默认情况下，所有引用类型都继承自 Object，这也是通过原型链实现的。任何函数的默认原型都是一个 Object 的实例，这意味着这个实例有一个内部指针指向Object.prototype。这也是为什么自定义类型能够继承包括 toString()、valueOf()在内的所有默认方法的原因。

原型与继承关系

有两种方法可以确定原型与实例关系：

instanceOf
Object.prototype.isPrototypeOf()

关于方法

子类有时候需要覆盖父类的方法，或者增加父类没有的方法。为此，这些方法必须在原型赋值之后再添加到原型上。

原型链的问题

1.原型链虽然是实现继承的强大工具，但它也有问题。主要问题出现在原型中包含引用值的时候。前面在谈到原型的问题时也提到过，原型中包含的引用值会在所有实例间共享，这也是为什么属性通常会在构造函数中定义而不会定义在原型上的原因。在使用原型实现继承时，原型实际上变成了另一个类型的实例。这意味着原先的实例属性摇身一变成为了原型属性。

function SuperType() {

this.colors = ["red", "blue", "green"];

}

function SubType() {}

// 继承 SuperType

SubType.prototype = new SuperType();

let instance1 = new SubType();

instance1.colors.push("black");

console.log(instance1.colors); // "red,blue,green,black"

let instance2 = new SubType();

console.log(instance2.colors); // "red,blue,green,black"

2.子类型在实例化时不能给父类型的构造函数传参。事实上，我们无法在不影响所有对象实例的情况下把参数传进父类的构造函数。再加上之前提到的原型中包含引用值的问题，就导致原型链基本不会被单独使用。

盗用构造函数

为了解决原型包含引用值导致继承的问题，诞生了盗用构造函数，基本思路很简单：在子类构造函数中调用父类构造函数，可以使用apply()和call()方法以新创建的对象为上下文构造函数。

function SuperType() {

this.colors = ["red", "blue", "green"];

}

function SubType() {

// 继承 SuperType

SuperType.call(this);

}

let instance1 = new SubType();

instance1.colors.push("black");

console.log(instance1.colors); // "red,blue,green,black"

let instance2 = new SubType();

console.log(instance2.colors); // "red,blue,green"

这样每个实例会有自己的colors属性。

传递参数：

function SuperType(name){

this.name = name;

}

function SubType() {

// 继承 SuperType 并传参

SuperType.call(this, "Nicholas");

// 实例属性

this.age = 29;

}

let instance = new SubType();

console.log(instance.name); // "Nicholas";

console.log(instance.age); // 29

缺点：

盗用构造函数的主要缺点，也是使用构造函数模式自定义类型的问题：必须在构造函数中定义方法，因此函数不能重用。此外，子类也不能访问父类原型上定义的方法，因此所有类型只能使用构造函数模式。由于存在这些问题，盗用构造函数基本上也不能单独使用。

function SuperType() {

this.colors = ["red", "blue", "green"];

}

SuperType.prototype.sayHi = function() {

console.log('SuperType');

};

function SubType() {

// 继承 SuperType

SuperType.call(this);

}

let instance1 = new SubType();

console.log(instance1.sayHi()); // 无法访问

组合继承

如名字一般综合了原型链和盗用构造函数，将两者的优点集中起来。基本的思路是使用原型链继承原型上的属性和方法，而通过盗用构造函数继承实例属性。这样既可以把方法定义在原型上以实现重用，又可以让每个实例都有自己的属性。

function SuperType(name){

this.name = name;

this.colors = ["red", "blue", "green"];

}

SuperType.prototype.sayName = function() {

console.log(this.name);

};

function SubType(name, age){

// 继承属性

SuperType.call(this, name);

this.age = age;

}

// 继承方法

SubType.prototype = new SuperType();

SubType.prototype.sayAge = function() {

console.log(this.age);

};

let instance1 = new SubType("Nicholas", 29);

instance1.colors.push("black");

console.log(instance1.colors); // "red,blue,green,black"

instance1.sayName(); // "Nicholas";

instance1.sayAge(); // 29

let instance2 = new SubType("Greg", 27);

console.log(instance2.colors); // "red,blue,green"

instance2.sayName(); // "Greg";

instance2.sayAge(); // 27

组合继承弥补了原型链和盗用构造函数的不足，是 JavaScript 中使用最多的继承模式。而且组合继承也保留了 instanceof 操作符和 isPrototypeOf()方法识别合成对象的能力。

原型式继承

该方法的原理是创建一个构造函数，构造函数的原型指向对象，然后调用 new 操作符创建实例，并返回这个实例，本质是一个浅拷贝。

function object(o) {

function F() {}

F.prototype = o;

return new F();

}

ECMAScript 5 通过增加 Object.create()方法将原型式继承的概念规范化了。这个方法接收两个参数：作为新对象原型的对象，以及给新对象定义额外属性的对象（第二个可选）。在只有一个参数时，Object.create()与这里的 object()方法效果相同：

let person = {

friends: ["Shelby", "Court", "Van"]

};

let anotherPerson = Object.create(person);

anotherPerson.name = "Greg";

anotherPerson.friends.push("Rob");

let yetAnotherPerson = Object.create(person);

yetAnotherPerson.name = "Linda";

yetAnotherPerson.friends.push("Barbie");

console.log(person.friends); // "Shelby,Court,Van,Rob,Barbie"

原型式继承非常适合不需要单独创建构造函数，但仍然需要在对象间共享信息的场合。但要记住，属性中包含的引用值始终会在相关对象间共享，跟使用原型模式是一样的。

寄生式继承

与原型式继承比较接近的一种继承方式是寄生式继承（parasitic inheritance），也是 Crockford 首倡的一种模式。寄生式继承背后的思路类似于寄生构造函数和工厂模式：创建一个实现继承的函数，以某种方式增强对象，然后返回这个对象。基本的寄生继承模式如下：

function createAnother(original){

let clone = object(original); // 通过调用函数创建一个新对象

clone.sayHi = function() { // 以某种方式增强这个对象

console.log("hi");

};

return clone; // 返回这个对象

}

在这段代码中，createAnother()函数接收一个参数，就是新对象的基准对象。这个对象 original会被传给 object()函数，然后将返回的新对象赋值给 clone。接着给 clone 对象添加一个新方法sayHi()。最后返回这个对象。可以像下面这样使用 createAnother()函数：

let person = {

friends: ["Shelby", "Court", "Van"]

};

let anotherPerson = createAnother(person);

anotherPerson.sayHi(); // "hi"

这个例子基于 person 对象返回了一个新对象。新返回的 anotherPerson 对象具有 person 的所有属性和方法，还有一个新方法叫 sayHi()。寄生式继承同样适合主要关注对象，而不在乎类型和构造函数的场景。object()函数不是寄生式继承所必需的，任何返回新对象的函数都可以在这里使用。

注意：通过寄生式继承给对象添加函数会导致函数难以重用，与构造函数模式类似。

寄生式组合继承

寄生式组合继承是来解决组合继承中的效率问题，它的效率问题是是父类构造函数始终会被调用两次：一次在是创建子类原型时调用，另一次是在子类构造函数中调用。

function SuperType(name) {

this.name = name;

this.colors = ["red", "blue", "green"];

}

SuperType.prototype.sayName = function() {

console.log(this.name);

};

function SubType(name, age){

SuperType.call(this, name); // 第二次调用 SuperType()

this.age = age;

}

SubType.prototype = new SuperType(); // 第一次调用 SuperType()

SubType.prototype.constructor = SubType;

SubType.prototype.sayAge = function() {

console.log(this.age);

};

寄生式组合继承通过盗用构造函数继承属性，但使用混合式原型链继承方法。基本思路是不通过调用父类构造函数给子类原型赋值，而是取得父类原型的一个副本。说到底就是使用寄生式继承来继承父类原型，然后将返回的新对象赋值给子类原型。寄生式组合继承的基本模式如下所示：

function inheritPrototype(subType, superType) {

let prototype = object(superType.prototype); // 创建对象

prototype.constructor = subType; // 增强对象

subType.prototype = prototype; // 赋值对象

}

这个 inheritPrototype()函数实现了寄生式组合继承的核心逻辑。这个函数接收两个参数：子类构造函数和父类构造函数。在这个函数内部，第一步是创建父类原型的一个副本。然后，给返回的prototype 对象设置 constructor 属性，解决由于重写原型导致默认 constructor 丢失的问题。最后将新创建的对象赋值给子类型的原型。如下例所示，调用 inheritPrototype()就可以实现前面例子中的子类型原型赋值：

function SuperType(name) {

this.name = name;

this.colors = ["red", "blue", "green"];

}

SuperType.prototype.sayName = function() {

console.log(this.name);

};

function SubType(name, age) {

SuperType.call(this, name);

this.age = age;

}

inheritPrototype(SubType, SuperType);

SubType.prototype.sayAge = function() {

console.log(this.age);

};

这里只调用了一次 SuperType 构造函数，避免了 SubType.prototype 上不必要也用不到的属性，因此可以说这个例子的效率更高。而且，原型链仍然保持不变，因此 instanceof 操作符和isPrototypeOf()方法正常有效。寄生式组合继承可以算是引用类型继承的最佳模式。

原文：JavaScript高级程序设计(第四版)