Javascript 中万事万物皆是对象， 虽然不严谨(JS中数据类型除了对象还有其他基本类型)。一定程度上表明了它本质上是一门面向对象的语言，即使它实现面向对象是基于原型。
从开始学习JS，面向对象的三大圣经(特性)：封装、继承、多态，一直作为JS 中最佳实践的标准，但是随着知识积累, 你可能有类似这样的一些疑问：
1、JS中又没有“类”这样的实现，为什么需要定义一个类似“类”一样的东西？
2、JS中实现面向对象通过原型的思想，按照传统面向对象多态的实践必然会导致代码的bug。
3、JS 中的最佳实践到底是什么？
....
其实这些问题都是一个问题，传统的面向对象的设计是否适合JS。
要回答这个问题需要先弄明白2个概念：类与原型。
类理论
类 / 继承描述了一种代码的组织结构形式——一种在软件中对真实世界中问题领域的建模方法。
类，是一种抽象的表示，对应 "类" 的是"实例"。
举个栗子，建筑师绘制会绘制出一个建筑的所有特性：高，宽，多少个房间甚至多少个窗户等等，但是他不会关心需要建多少个这样的建筑，他也不会关心，建筑使用的什么水泥和钢铁。施工人员会基于建筑师的蓝图来建造。完成之后，建筑就成了蓝图的物理的实例，蓝图就是抽象的类。
把类和实例对象之间的关系看作是直接关系而不是间接关系通常更有助于理解。类通过复制操作被实例化为对象形式:
箭头的方向是从左向右、从上向下，它表示概念和物理意义上发生的复制操作。
在许多面向类的语言中，“标准库”会提供 Stack 类，它是一种“栈”数据结构(支持压 入、弹出，等等)。Stack 类内部会有一些变量来存储数据，同时会提供一些公有的可访问 行为(“方法”)，从而让你的代码可以和(隐藏的)数据进行交互(比如添加、删除数据)。
但是在这些语言中，你实际上并不是直接操作 Stack(除非创建一个静态类成员引用，这超出了我们的讨论范围)。Stack 类仅仅是一个抽象的表示，它描述了所有“栈”需要做的 事，但是它本身并不是一个“栈”。你必须先实例化 Stack 类然后才能对它进行操作。
原型
JavaScript 常被描述为一种基于原型的语言 (prototype-based language)——每个对象拥有一个原型对象，对象以其原型为模板、从原型继承方法和属性。原型对象也可能拥有原型，并从中继承方法和属性，一层一层、以此类推。这种关系常被称为原型链 (prototype chain)，它解释了为何一个对象会拥有定义在其他对象中的属性和方法。
JS中所有内置对象以及通过字面量声明的对象的原型都最终指向Object.prototype。原型对象是JS实现面向对象的基础，所以说JS中万物皆对象也有一定的道理，因为它不存在类的概念。所有通过New关键字实例化的过程，并不是复制的过程，而是链接的过程，将原型链接到生成的对象的过程。
这一张图或许你很熟悉，它将实例对象与原型对象之前的关系表示了出来。
通过上面的介绍，我们了解到：
- JS 中没有类的概念（ES6中新增的class 的实践也只是原型模式的语法糖），实现继承是通过原型，实现的过程是链接而不是复制，所以一旦修改了原型对象（类中的父类），就会影响造成所有关联的子对象（基于类的实现中不会有这样的问题，每一个实例都是相对独立的存在）。
- 多态必将是一个丑陋的实践。由于对象之间是关联的关系，所以要实现方法的多态，将会覆盖原型链上原本的方法的实践，从而影响整个关联的对象。
然而问题来了，我们如果不按照面向对象的特性来实践，为之奈何。
面向委托
这是一种极其强大的设计模式，和父类、子类、继承、多态等概念完全不同。在你的脑海中
对象并不是按照父类到子类的关系垂直组织的，而是通过任意方向的委托关联并排组织的。
由于原型链等特性的存在，在不同对象之间功能的共享通常被叫做 委托 - 特殊的对象将功能委托给通用的对象类型完成。这也许比将其称之为继承更为贴切，因为“被继承”了的功能并没有被拷贝到正在“进行继承”的对象中，相反它仍存在于通用的对象中。
下面是面向对象(类)和面向委托的实践对比。
面向对象风格("原型")
function Foo(who) {
this.me = who;
}
Foo.prototype.identify = function () {
return "I am " + this.me;
};
function Bar(who) {
Foo.call(this, who);
}
Bar.prototype = Object.create(Foo.prototype);
Bar.prototype.speak = function () {
alert("Hello, " + this.identify() + ".");
};
const b1 = new Bar("b1");
const b2 = new Bar("b2");
b1.speak();
b2.speak();
子类 Bar 继承了父类 Foo，然后生成了 b1 和 b2 两个实例。b1 委托了 Bar.prototype，后者委托了 Foo.prototype。
面向委托风格(对象关联)
Foo = {
init: function (who) {
this.me = who;
},
identify: function () {
return "I am " + this.me;
}
};
Bar = Object.create(Foo);
Bar.speak = function () {
alert("Hello, " + this.identify() + ".");
};
const b1 = Object.create(Bar);
b1.init("b1");
const b2 = Object.create(Bar);
b2.init("b2");
b1.speak();
b2.speak();
思维模型：
这段代码中同样利用 [[Prototype]] 把 b1 委托给 Bar 并把 Bar 委托给 Foo，和上一段代码一模一样, 仍然实现了三个对象之间的关联。
对比两种实现方式，面向委托的设计更加简洁。只是把对象关联起来，并不需要做那些复杂又让人困惑的模仿类的行为(构造函数，原型，以及new)。
并且对象关联可以更好地支持关注分离(separation of concerns)原则，创建和初始化并不需要们出现在不同的位置，合并为一个步骤。
总结来说，我们在后续的实践中，可以尝试采用面向委托的模式，因为它更贴近JS语言的设计思想。
但是并不是说我们要抛弃面向对象，面向对象的思想也是很重要的。它提供的思维模式，让我们把物理世界的事物抽象成对象, 这是面向对象语言编程的基础。所以我们可以基于面向的对象的思想来完成物理世界的抽象以及封装，使用面向委托的思想来构建对象，同样的在JS 中采用函数式编程的思想来执行，这才是王道。
- 参考:《你所不知道的Javascript》
