继承
面向对象有三大特征：继承、多态和封装。这篇文章主要与继承相关。 继承最大的优点是可以实现复用，减少重复造轮。继承的内容包括属性和方法。继承的来源可以来自一处或多处。有些语言支持多重继承，如C++；Java以及Javascript都是唯一继承。其中，Java是基于类的继承，而Javascript是基于原型/对象的继承。
原型与__proto__和prototype属性
在Javascript世界中，原型就是对象。原型就是实现继承的主要方式之一。在构建一个新的对象时，要将某个对象作为其原型，与其关联起来。这里需要先熟悉构造器函数的概念。
function Person(name, age) {
this.name = name
this.age = age
}
let person = new Person('ivy', 25) //构造器调用
let person2 = Person('angie', 26) //普通函数调用
构造器函数就是用于创建对象的函数。上例的person对象就是通过Person构造器生成的。而Person函数也只有跟在关键字new后面才发挥的是构造器的作用.
New关键字调用
New关键字调用大约实现了如下的潜在功能：生成一个新对象，赋值给this, 将该对象的原型（this.__proto__ = Person.prototype）指向构造器的prototype, 执行构造器函数体，忽略函数返回值，返回this对象。
function Person(name, age) {
this.name = name
this.age = age
return 'person-info' //在构造器调用中被忽略
}
let person = new Person('ivy', 26)
person !== 'person-info'' // true, person: {name: 'ivy', age: 26....}
其他几种原型操作
/*** Object.create ***/
let t = Object.create({ age: 26 }, {name: {value: 'ivy'}}) //t.__proto__ = { age: 26 }
/*** setPrototypeOf **/
let obj = {}
Object.setPrototypeOf(obj, {age: 26}) //obj.__proto__ = { age: 26 }
/*** __proto__ ***/
let t = {}
let s = {age: 26}
t.__proto__ = s //t.__proto__ = { age: 26 }
prototype属性
prototype是Javascript内置对象Function上的一个属性，值为对象引用。当我们定义一个构造器函数时候，该构造器指向一个默认的以Object.prototype为原型的原型对象（Person.prototype !== Object.prototype 但是 Person.prototype.__proto__ === Object.prototype), 若是我们修改构造器的prototype属性值（Person.prototype = {}），并不会影响之前已经创建过的对象的原型指针。
通过prototype来实现继承：
function Person(name, age) {
this.name = name
this.age = age
}
Person.prototype.getName = function() {
return this.name
}
function Man(name, age) {
Person.apply(this, [name, age])
this.gender = 'male'
}
Man.prototype = new Person('angie', 30)
let person = new Man('ivy', 26)
person.getName() // 'ivy'
Constructor
constructor是构造器的prototype属性上的一个属性。 当我们定义一个构造器时， 值应该指向构造器本身。
Person.prototype.constructor // ƒ Person(name, age) { this.name = name this.age = age}
但是当我们另外为构造器指定新的原型对象，要记得手动修改constructor属性，否则，constructor会指向新的原型对象上的constructor值。
Person.prototype = {}
Person.prototype.constructor //ƒ Object() { [native code] }
/*** 注意需要手动 ***/
Person.prototype.constructor = Person
根据上面prototype小节的内容，我们可以看到所有构造器上的原型属性都可以在利用构造器生成的对象上访问，因此我们在对象上可以便捷地访问到它的构造器。
let person = new Person('ivy', 26)
person.constructor // ƒ Person(name, age) { this.name = name this.age = age }
我们通过原型对象来继承，而constructor则可以帮我们快速定位对象的构造器。
let arr = [1,2,3,4]
arr.constructor === Array // true
Prototype Chain
每个对象都有自己的原型，也可以被别人当作原型。因此，对象的背后会形成一个原型链。原型链上的属性对于对象而言是可见。当通过对象去访问某个属性名时，javascript引擎会一层一层的去找原型链上的对象，直到找到第一个符合的值。而对于写操作，则相对复杂。
属性遮蔽
当对对象进行写操作时候，可能会屏蔽属性。这边我们先分辨一下javascript中属性的定义与赋值两种操作。
let s = {}
s.operationName = '定义与赋值兼之'
s.operationName = '赋值操作'
//定义命名数据属性
Object.defineProperty(s, 'newOperationName', {
value: 12,
configurable: true,
enumerable: true,
writable: true
})
//定义访问器属性
let valStorage = 2
Object.defineProperty(s, 'newOperationName2', {
set (val) {
valStorage = val
},
get () {return valStorage
}
})
现在回到对对象的写操作上。当我们尝试对对象进行写时，在原型链上已有命名属性定义，这时候该命名属性对于对象来说是只读的，无法被修改，只能被覆盖。它将尝试在对象自己的身上定义一个同名命名属性，然后赋值。这便是属性遮蔽。
function Person(name, age) {
this.name = name
this.age = age
}
let personPrototype = {
constructor: Person,
named: true,
getName: function() { return this.name }
}
let domain = 'domain-a'
Object.defineProperty(personPrototype, 'domain', {
set(val) {console.log('setting domain as ', val)
domain = val
},
get() {
return domain
}
})
Person.prototype = personPrototype
let person = new Person('ivy', 26) // person.__proto__.named: true
person.named = false // person.__proto__.named: true, person.named: false
person.domain = 'domain-b' // setting domain as domain-b
若是原型链上找到的是访问器属性，进行的是赋值操作，则不会有遮蔽效果。
性能
在原型链上查找属性比较耗时，对性能有副作用，这在性能要求苛刻的情况下很重要。另外，试图访问不存在的属性时会遍历整个原型链。
遍历对象的属性时，原型链上的每个可枚举属性都会被枚举出来。要检查对象是否具有自己定义的属性，而不是其原型链上的某个属性，则必须使用所有对象从 Object.prototype 继承的 hasOwnProperty 方法。
除此之外，Object.keys()也不遍历原型链。
