23. 能不能描述一下原型链？

1. 能不能描述一下原型链？

JavaScript对象通过proto 指向父类对象，直到指向Object对象为止，这样就形成了一个原型指向的链条, 即原型链。

对象的 hasOwnProperty() 来检查对象自身中是否含有该属性使用 in 检查对象中是否含有某个属性时，如果对象中没有但是原型链中有，也会返回 true

1. JS如何实现继承？

第一种: 借助call

function Parent1(){ this.name = 'parent1';

} function Child1(){

Parent1.call(this);

this.type = 'child1' }

第二种: 借助原型链

function Parent2() { this.name = 'parent2';

this.play = [1, 2, 3] }

function Child2() { this.type = 'child2';

} Child2.prototype = new Parent2();

console.log(new Child2());

看似没有问题，父类的方法和属性都能够访问，但实际上有一个潜在的不足。举个例子：

var s1 = new Child2();

var s2 = new Child2();

s1.play.push(4);

console.log(s1.play, s2.play);

可以看到控制台：

明明我只改变了s1的play属性，为什么s2也跟着变了呢？很简单，因为两个实例使用的是同一个原型对象。

那么还有更好的方式么？

第三种：将前两种组合

function Parent3 () { this.name = 'parent3';

this.play = [1, 2, 3];

} function Child3() {

Parent3.call(this);

this.type = 'child3';

} Child3.prototype = new Parent3();

var s3 = new Child3();

var s4 = new Child3();

s3.play.push(4);

console.log(s3.play, s4.play);

可以看到控制台：

第四种: 组合继承的优化1

function Parent4 () { this.name = 'parent4';

this.play = [1, 2, 3];

} function Child4() {

Parent4.call(this);

this.type = 'child4';

} Child4.prototype = Parent4.prototype;

这里让将父类原型对象直接给到子类，父类构造函数只执行一次，而且父类属性和方法均能访问，但是我们来测试一下：

var s3 = new Child4();

var s4 = new Child4();

console.log(s3)

子类实例的构造函数是Parent4，显然这是不对的，应该是Child4。

第五种(最推荐使用): 组合继承的优化1

function Parent5 () { this.name = 'parent5';

this.play = [1, 2, 3];

} function Child5() {

Parent5.call(this);

this.type = 'child5';

} Child5.prototype = Object.create(Parent5.prototype);

Child5.prototype.constructor = Child5;

这是最推荐的一种方式，接近完美的继承，它的名字也叫做寄生组合继承。

function _possibleConstructorReturn(self, call) { // ...

return call && (typeof call === 'object' || typeof call === 'function') ?

call : self;

}

function _inherits(subClass, superClass) { // ...

//看到没有 subClass.prototype = Object.create(superClass && superClass.prototype, {

constructor: { value: subClass,

enumerable: false, writable: true,

configurable: true }

});

if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;

}

var Parent = function Parent() { // 验证是否是 Parent 构造出来的 this

_classCallCheck(this, Parent);

};

var Child = (function (_Parent) { _inherits(Child, _Parent);

function Child() { _classCallCheck(this, Child);

return _possibleConstructorReturn(this, (Child.__proto__ || Object.getPrototypeOf(Child)).apply(this, arguments));

}

return Child;

}(Parent));

核心是_inherits函数，可以看到它采用的依然也是第五种方式————寄生组合继承方式，同时证明了这种方式的成功。不过这里加了一个Object.setPrototypeOf(subClass, superClass)，这是用来干啥的

呢？

答案是用来继承父类的静态方法。这也是原来的继承方式疏忽掉的地方。

追问: 面向对象的设计一定是好的设计吗？

不一定。从继承的角度说，这一设计是存在巨大隐患的。

class Car{ constructor(id) {

this.id = id;

} drive(){

console.log("wuwuwu!");

} music(){

console.log("lalala!")

} addOil(){

console.log("哦哟！")

} }

class otherCar extends Car{}

现在可以实现车的功能，并且以此去扩展不同的车。

但是问题来了，新能源汽车也是车，但是它并不需要addOil(加油)。

如果让新能源汽车的类继承Car的话，也是有问题的，俗称"大猩猩和香蕉"的问题。大猩猩手里有香蕉，但是我现在明明只需要香蕉，却拿到了一只大猩猩。也就是说加油这个方法，我现在是不需要的，但是

由于继承的原因，也给到子类了。

继承的最大问题在于：无法决定继承哪些属性，所有属性都得继承。

当然你可能会说，可以再创建一个父类啊，把加油的方法给去掉，但是这也是有问题的，一方面父类是无法描述所有子类的细节情况的，为了不同的子类特性去增加不同的父类，代码势必会大量重复，另一

方面一旦子类有所变动，父类也要进行相应的更新，代码的耦合性太高，维护性不好。

那如何来解决继承的诸多问题呢？

用组合，这也是当今编程语法发展的趋势，比如golang完全采用的是面向组合的设计方式。

顾名思义，面向组合就是先设计一系列零件，然后将这些零件进行拼装，来形成不同的实例或者类。

function drive(){ console.log("wuwuwu!");

} function music(){

console.log("lalala!")

} function addOil(){

console.log("哦哟！")

}

let car = compose(drive, music, addOil);

let newEnergyCar = compose(drive, music);

代码干净，复用性也很好。这就是面向组合的设计方式。