继续
我们晓得JS是OO编程，天然少不了OO编程所具有的特征，进修完原型以后，我们一气呵成，来聊聊OO编程三大特征之一——继续。
继续这个词应当比较好明白，我们耳熟能详的，继续财富，继续家业等，他们的条件是有个继续人，然后你是继续者，如许才有继续而言。没错，JS中的继续正如你所明白的一样，也是成对涌现的。
继续就是将对象的属性复制一份给须要继续的对象
OO言语支撑两种继续体式格局：接口继续和完成继续，个中接口继续只继续要领署名，而完成继续则继续现实的要领。由于ECMAScript中的函数没有署名，因而没法完成接口继续，只支撑完成继续，而继续的重要体式格局，是经由历程原型链完成的，要明白原型链，起首要晓得什么是原型，不懂的小伙伴，能够看这篇博文一眼看穿👀JS原型。
实在继续说白了就是
①它上面必需有个父级
②且它获取了这个父级的一切实例和要领
这里提高一个小观点，上文提到的没有署名，第一次看这个字眼也不是很懂，搜刮了一下，以为这个说法照样比较承认的。
没有署名
我们晓得JS是弱范例言语，它的参数能够由0个或多个值的数组来示意，我们能够为JS函数定名参数，这个做法只是为了轻易，但不是必需，也就是说，
我们命不定名参数和传不传参数没有必然联系，既能够定名参数，但不传(此时默以为undefined)，也能够不定名参数，但传参数，这类写法在JS中是正当的，反之，强范例言语，对这个请求就异常严厉，定义了几个参数就一定要传几个参数下去。
定名参数这块必需请求事前建立函数署名，而未来的挪用也必需与该署名一致。(也就是说定义几个参数就要传几个下去)**，而js没有这些条条框框，解析器不会考证定名参数，所以说js没有署名。
举个🌰
function JSNoSignature () {
console.log("first params" + arguments[0] + "," + "second params" + arguments[1]);
}
JSNoSignature ("hello", "world");这个🌰很明显了。定名参数为空，但我们照旧能够传参，挪用该要领。所谓的参数范例，参数个数，参数位置，相差参数，js一切不关心，它一切的值都被放到arguments中了，须要返回值的话直接return，没必要声明，这就叫做js没有署名。
原型链
什么是原型链呢？字面上也很好明白，就是将一切的原型串在一起就叫做原型链。固然这个诠释只是为了轻易明白罢了，原型链是作为完成继续的重要要领，其基本头脑是应用原型让一个援用范例继续另一个援用范例的属性和要领。我们晓得每一个组织函数都有一个原型对象，原型对象都包括一个指向组织函数的指针，而实例都包括一个指向原型的内部指针。此时，假如我们让原型对象即是别的一个范例的实例，那末此时的原型对象将包括一个指向另一个原型的指针，响应地，另一个原型中也包括着一个指向另一个组织函数的指针，这类循环往复的衔接关联，就构成了实例与原型的链条，这就是原型链。
一句话说白了，就是实例→原型→实例→原型→实例… 衔接下去就是原型链。
我以为继续就是原型链的一种表现情势。
我们晓得了原型链后，要晓得他怎样去运用，ECMA供应一套原型链的基本情势基本情势👇
原型链的基本情势
// 建立一个父类
function FatherType(){
this.fatherName = '定名最头痛';
}
FatherType.prototype.getFatherValue = function() {
return this.fatherName;
}
function ChildType(){
this.childName = 'George';
}
// 继续了FatherType，行将一个实例赋值给函数原型，我们就说这个原型继续了另一个函数实例
// 将子类的原型指向这个父类的实例
ChildType.prototype = new FatherType();
ChildType.prototype.getChildValue = function() {
return this.childName;
}
let instance = new ChildType();
console.log(instance.getFatherValue()); // 定名最头痛
挪用instance.getFatherValue()时会阅历三个搜刮步骤
①搜刮实例
②搜刮ChildType.prototype
③搜刮FatherType.prototype，此时在这步找到该要领，在找不到属性或要领的情况下，搜刮历程老是要一环一环地向前行到原型链末尾才会停下来。
此时的原型链是instance → ChildType.prototype → FatherType.prototype
实行instance.getFatherValue()后，getFatherValue内里的this是ChildType，此时ChildType会依据原型链去找fatherName属性，终究在FatherType中找到。
此时instance.constructor是指向FatherType的
默许的原型
一切的援用范例默许都继续了Object，而这个继续也是经由历程原型链完成的，因而，
一切函数的默许原型都是Object的实例，因而默许原型都邑包括一个内部指针，指向Object。prototype，这也就是一切自定义范例都邑继续toString()，valueOf()等默许要领的根本缘由。Array范例也是继续了Object范例的。
因而，我们能够总结一下，在原型链的最顶端就是Object范例，一切的函数默许都继续了Object中的属性。
原型和实例关联的确认
isPrototypeOf要领
在一眼看穿👀JS原型中我们有提到过isPrototypeOf要领能够用于推断这个实例的指针是不是指向这个原型，这一章我们进修了原型链，这里做个补充，根据原型链的先后顺序，isPrototypeOf要领能够用于推断这个实例是不是属于这个原型的。
照旧用上面谁人🌰
// 注重，这里用的是原型，Object.prototype，FatherType.prototype，ChildType.prototype
console.log(Object.prototype.isPrototypeOf(instance)); // true
console.log(FatherType.prototype.isPrototypeOf(instance)); // true
console.log(ChildType.prototype.isPrototypeOf(instance)); // true下面再引见另一种要领，经由历程instanceof操作符，也能够肯定原型和实例之间的关联
instanceof操作符
instanceof操作符是用来测试原型链中的组织函数是不是有这个实例
console.log(instance instanceof Object); // true
console.log(instance instanceof FatherType); // true
console.log(instance instanceof ChildType); // true与isPrototypeOf差别的是，前者用的是原型，后者用的是组织函数
定义要领时须要注重的题目
①给原型增加要领的代码一定要放在继续以后，这是由于，在继续的时刻被继续者会掩盖掉继续者原型上的一切要领
function FatherType(){
this.fatherName = '定名最头痛';
}
FatherType.prototype.getFatherValue = function() {
return this.fatherName;
}
function ChildType(){
this.childName = 'George';
}
// 继续了FatherType
ChildType.prototype = new FatherType();
// 建立实例
let instance = new ChildType();
// 为ChildType原型上增加新要领，要放在继续FatherType以后，这是由于new FatherType()会将ChildType原型上增加的新要领悉数掩盖掉
ChildType.prototype.getChildValue = function() {
return this.childName;
}
// 此时getFatherValue被重写了
ChildType.prototype.getFatherValue = function() {
return true
}
console.log(instance.getFatherValue()); // true ②经由历程原型链完成继续时，不能运用对象字面量建立原型要领，由于如许会重写原型链。这部份的🌰和诠释在一眼看穿👀JS原型中《原型对象的题目》这一小节已表述过了。一样的原理，只不过把原型换成了原型链罢了。
原型链的bug
原型链虽然壮大，能够用它来完成继续，然则也是存在bug的，它最大的bug来自包括援用范例值的原型。也就是说原型链上面定义的原型属性会被一切的实例同享。
它还有别的一个bug，即在建立子范例的实例时，不能向父范例（超范例）的组织函数中通报参数。或者说没有办法在不影响一切对象实例的情况下，给超范例的组织函数通报参数。
基于以上这两个缘由，实践历程当中很少会零丁运用原型链
借用组织函数
其设想头脑就是在子范例组织函数的内部挪用父类(超类)组织函数。
由于函数只不过是在特定环境中实行代码的对象，因而经由历程apply()和call()要领也能够在(未来)新建立的对象上实行组织函数。
function FatherType() {
this.name = 'George';
}
function ChildType() {
//经由历程call要领转变this的指向，此时FatherType中的this指的是ChildType，相当于在组织函数中定义本身的属性。
FatherType.call(this);
}
let instance1 = new ChildType();
instance1.name = '定名最头痛';
console.log(instance1.name); // '定名最头痛'
let instance2 = new ChildType();
console.log(instance2.name); // George经由历程上述要领很好处理了原型属性同享题目，另外，既然是一个函数，它也能传响应的参数，因而也能完成在子范例组织函数中向超范例组织函数通报参数。
function FatherType(name){
this.name = name
}
function ChildType(){
FatherType.call(this, "George");
this.age = 18
}
let instance = new ChildType();
console.log(instance.name); // George
console.log(instance.age); // 18借用组织函数的题目
借用组织函数，要领都在组织函数中定义，那末函数的复用就无从谈起，而且在父类(超范例)的原型定义的要领，对子范例而言也是不可见的，效果一切范例都只能运用组织函数情势。
组合继续
组合继续也叫伪典范继续，其设想头脑是将原型链和借用组织函数的手艺组合到一块，发挥两者之长的一种继续情势，其背地的思绪是运用原型链完成对原型属性和要领的继续，而经由历程借用组织函数来完成对实例属性的继续，如许既经由历程在原型上定义要领完成了函数复用，又能够保证每一个实例都有它本身的属性。
function FatherType(name){
this.name = name
this.colors = ['red', 'blue', 'green']
}
FatherType.prototype.sayName = function() {
console.log(this.name)
}
// 借用组织函数完成对实例的继续
function ChildType(name, age){
// 运用call要领继续FatherType中的属性
FatherType.call(this, name);
this.age = age
}
// 应用原型链完成对原型属性和要领的继续
ChildType.prototype = new FatherType(); //将FatherType的实例赋值给ChildType原型
ChildType.prototype.constructor = ChildType; // 让ChildType的原型指向ChildType函数
ChildType.prototype.sayAge = function(){
console.log(this.age)
}
let instance1 = new ChildType('定名最头痛', 18);
instance1.colors.push('black');
console.log(instance1.colors); // 'red, blue, green, black'
instance1.sayName();
instance1.sayAge();
var instance2 = new ChildType('定名最头痛', 18);
console.log(instance2.colors); // 'red, blue, green'
instance2.sayName(); // '定名最头痛'
instance2.sayAge(); // 18组合继续体式格局避免了原型链和借用组织函数的缺点，是JS中经常使用的继续体式格局。
原型链继续
原型链继续没有运用严厉意义上的组织函数，其头脑是基于已有的对象建立新对象
// 此object函数返回一个实例, 现实上object()对传入个中的对象实行了一次浅复制.
function object(o) {
function F() {} // 建立一个暂时组织函数
F.prototype = o; // 将传入的对象作为组织函数的原型
return new F(); // 返回这个暂时组织函数的新实例
}
let demo = {
name: 'George',
like: ['apple', 'dog']
}
let demo1 = object(demo);
demo1.name = '定名'; // 基本范例
demo1.like.push('cat'); // 援用范例共用一个内存地址
let demo2 = object(demo);
demo2.name = '头痛'; // 基本范例
demo2.like.push('chicken') // 援用范例共用一个内存地址
console.log(demo.name) // George
console.log(demo.like) // ["apple", "dog", "cat", "chicken"]原型链继续的条件是必需要有一个对象能够作为另一个对象的基本。经由历程object()函数天生新对象后，再依据需求对新对象举行修正即可。 由于新对象(demo1, demo2)是将传入对象(demo)作为原型的，因而当涉及到援用范例时，他们会共用一个内存地址，援用范例会被一切实例所同享，现实上相当于建立了demo对象的两个副本。
Object.create()要领
ECMA5中新增Object.create()要领范例化了原型式继续。该要领吸收两个参数
①基本对象，这个参数的现实作用是定义了模板对象中有的属性，就像上面🌰中的demo，只要一个参数情况下，Object.create()与上🌰中的object雷同
②这个是可选参数，一个为基本对象定义分外属性的对象, 该对象的誊写花样与Object.defineProperties()要领的第二个参数花样雷同，每一个属性都是经由历程本身的描述符定义的，以这类体式格局指定的任何属性都邑掩盖原型对象上的同名属性。
// 只要一个参数
var demoObj = {
name: 'George',
like: ['apple', 'dog', 'cat']
}
let demo1Obj = Object.create(demoObj);
demo1Obj.name = '定名';
demo1Obj.like.push('banana');
let demo2Obj = Object.create(demoObj);
demo2Obj.name = '头痛';
demo2Obj.like.push('walk');
console.log(demoObj.like) //["apple", "dog", "cat", "banana", "walk"]
// 两个参数
var demoObj = {
name: 'George',
like: ['apple', 'dog', 'cat']
}
let demo1Obj = Object.create(demoObj, {
name: {
value:'定名'
},
like:{
value: ['monkey']
},
new_val: {
value: 'new_val'
}
});
console.log(demoObj.name) // George
console.log(demo1Obj.name) // 定名
console.log(demo1Obj.like) // ["monkey"]
console.log(demo1Obj.new_val) // new_val
console.log(Object.getOwnPropertyDescriptor(demo1Obj,'new_val')) // {value: "new_val", writable: false, enumerable: false, configurable: false}
假如只想让一个对象与另一个对象坚持范例的情况下，原型式继续是完全能够胜任的，不过要注重的是，援用范例值的属性一直都邑同享响应的值。
寄生式继续
寄生式继续是与原型式继续严密相干的一种思绪，其设想头脑与寄生组织函数和工场情势相似，即建立一个仅用于封装继续历程的函数，该函数内部以某种体式格局来加强对象，末了返回一个对象。
// 这个函数所返回的对象，既有original的一切属性和要领，也有本身的sayHello要领
function createAnother(original) {
let clone = Object.create(original);
clone.sayHello = function(){
console.log('HELLO WORLD')
}
return clone;
}
let person = {
name: 'George',
foods: ['apple', 'banana']
}
let anotherPerson = createAnother(person);
anotherPerson.sayHello(); // HELLO WORLD运用寄生式继续来为对象增加函数，会由于不能做到函数复用而降低效率，这一点与组织函数情势相似。
寄生组合式继续
所谓寄生组合式继续，即经由历程借用组织函数来继续属性，经由历程原型链的夹杂情势来继续要领。其背地头脑：没必要为了指定子范例的原型而挪用超范例的组织函数，我们所须要的不过就是超范例原型的一个副本罢了。说白了就是运用寄生式继续来继续超范例的原型，然后再将效果指定给子范例的原型。
function inheritPrototype(childType, fatherType){
let fatherObj = Object.create(fatherType.prototype); // 建立对象
fatherObj.constructor = childType; // 填补重写原型而落空的默许constructor属性
childType.prototype = fatherObj; // 指定对象
}上🌰是寄生组合式继续最简朴的情势，这个函数接收两个参数：子范例组织函数和超范例组织函数，在函数内部，①建立了父范例原型的一个副本，②为建立的副本增加constructor属性，从而填补因重写原型而落空的默许的constructor属性。③将新建立的对象（即副本）赋值给子范例的原型。
function FatherType(name){
this.name = name;
this.foods = ['apple', 'banana'];
}
FatherType.prototype.sayName = function(){
console.log(this.name)
}
function ChildType(name, age){
FatherType.call(this, name);
this.age = age;
}
inheritPrototype(ChildType, FatherType);
ChildType.prototype.sayAge = function(){
console.log(this.age)
}小结
- JS继续的重要体式格局是经由历程原型链完成的
- 实例-原型-实例-原型…无穷链接下去就是原型链
- 一切援用范例的默许原型都是Object
- instanceof操作符和isPrototypeOf要领都能够用于推断实例与原型的关联，其区别是，前者用的是原型，后者用的是组织函数
- 给原型增加要领的代码一定要放在继续以后，这是由于，在继续的时刻被继续者会掩盖掉继续者原型上的一切要领
- Object.create()要领用于建立一个新对象，其属性会安排在该对象的原型上
- 继续有6种体式格局，分别是原型链，借用组织函数，组合继续，原型式继续，寄生式继续和寄生组合式继续
