类

ES2015/ES6 类优先与 ES5 纯函数

很难为经典的 ES5 类创建可读的的继承、 构造和方法定义。 如果你需要继承（并且感到奇怪为啥你不需
要）， 则优先用 ES2015/ES6的类。 不过， 短小的函数优先于类， 知道你发现你需要更大并且更复杂的
对象。

不好的：

  1. const Animal = function(age) {
  2.   if (!(this instanceof Animal)) {
  3.     throw new Error('Instantiate Animal with `new`');
  4.   }
  6.   this.age = age;
  7. };
  9. Animal.prototype.move = function move() {};
  11. const Mammal = function(age, furColor) {
  12.   if (!(this instanceof Mammal)) {
  13.     throw new Error('Instantiate Mammal with `new`');
  14.   }
  16.   Animal.call(this, age);
  17.   this.furColor = furColor;
  18. };
  20. Mammal.prototype = Object.create(Animal.prototype);
  21. Mammal.prototype.constructor = Mammal;
  22. Mammal.prototype.liveBirth = function liveBirth() {};
  24. const Human = function(age, furColor, languageSpoken) {
  25.   if (!(this instanceof Human)) {
  26.     throw new Error('Instantiate Human with `new`');
  27.   }
  29.   Mammal.call(this, age, furColor);
  30.   this.languageSpoken = languageSpoken;
  31. };
  33. Human.prototype = Object.create(Mammal.prototype);
  34. Human.prototype.constructor = Human;
  35. Human.prototype.speak = function speak() {};

好的

  1. class Animal {
  2.   constructor(age) {
  3.     this.age = age;
  4.   }
  6.   move() { /* ... */ }
  7. }
  9. class Mammal extends Animal {
  10.   constructor(age, furColor) {
  11.     super(age);
  12.     this.furColor = furColor;
  13.   }
  15.   liveBirth() { /* ... */ }
  16. }
  18. class Human extends Mammal {
  19.   constructor(age, furColor, languageSpoken) {
  20.     super(age, furColor);
  21.     this.languageSpoken = languageSpoken;
  22.   }
  24.   speak() { /* ... */ }
  25. }

使用方法链

这个模式在 JavaScript 中是非常有用的， 并且你可以在许多类库比如 jQuery 和 Lodash 中见到。
它允许你的代码变得富有表现力， 并减少啰嗦。 因为这个原因， 我说， 使用方法链然后再看看你的代码
会变得多么简洁。 在你的类／方法中， 简单的在每个方法的最后返回 this ， 然后你就能把这个类的
其它方法链在一起。

不好的：

  1. class Car {
  2.   constructor() {
  3.     this.make = 'Honda';
  4.     this.model = 'Accord';
  5.     this.color = 'white';
  6.   }
  8.   setMake(make) {
  9.     this.make = make;
  10.   }
  12.   setModel(model) {
  13.     this.model = model;
  14.   }
  16.   setColor(color) {
  17.     this.color = color;
  18.   }
  20.   save() {
  21.     console.log(this.make, this.model, this.color);
  22.   }
  23. }
  25. const car = new Car();
  26. car.setColor('pink');
  27. car.setMake('Ford');
  28. car.setModel('F-150');
  29. car.save();

好的：

  1. class Car {
  2.   constructor() {
  3.     this.make = 'Honda';
  4.     this.model = 'Accord';
  5.     this.color = 'white';
  6.   }
  8.   setMake(make) {
  9.     this.make = make;
  10.     // NOTE: Returning this for chaining
  11.     return this;
  12.   }
  14.   setModel(model) {
  15.     this.model = model;
  16.     // NOTE: Returning this for chaining
  17.     return this;
  18.   }
  20.   setColor(color) {
  21.     this.color = color;
  22.     // NOTE: Returning this for chaining
  23.     return this;
  24.   }
  26.   save() {
  27.     console.log(this.make, this.model, this.color);
  28.     // NOTE: Returning this for chaining
  29.     return this;
  30.   }
  31. }
  33. const car = new Car()
  34.   .setColor('pink')
  35.   .setMake('Ford')
  36.   .setModel('F-150')
  37.   .save();

组合优先于继承

正如设计模式四人帮所述， 如果可能，
你应该优先使用组合而不是继承。 有许多好的理由去使用继承， 也有许多好的理由去使用组合。这个格言
的重点是， 如果你本能的观点是继承， 那么请想一下组合能否更好的为你的问题建模。 很多情况下它真的
可以。

You might be wondering then, “when should I use inheritance?” It
depends on your problem at hand, but this is a decent list of when inheritance
makes more sense than composition:

那么你也许会这样想， “我什么时候改使用继承？” 这取决于你手上的问题， 不过这儿有一个像样的列表说
明什么时候继承比组合更好用：

  1. 你的继承表示”是一个”的关系而不是”有一个”的关系（人类->动物 vs 用户->用户详情）；
  2. 你可以重用来自基类的代码（人可以像所有动物一样行动）；
  3. 你想通过基类对子类进行全局的修改（改变所有动物行动时的热量消耗）；

不好的：

  1. class Employee {
  2.   constructor(name, email) {
  3.     this.name = name;
  4.     this.email = email;
  5.   }
  7.   // ...
  8. }
  10. // 不好是因为雇员“有”税率数据， EmployeeTaxData 不是一个 Employee 类型。
  11. class EmployeeTaxData extends Employee {
  12.   constructor(ssn, salary) {
  13.     super();
  14.     this.ssn = ssn;
  15.     this.salary = salary;
  16.   }
  18.   // ...
  19. }

好的：

  1. class EmployeeTaxData {
  2.   constructor(ssn, salary) {
  3.     this.ssn = ssn;
  4.     this.salary = salary;
  5.   }
  7.   // ...
  8. }
  10. class Employee {
  11.   constructor(name, email) {
  12.     this.name = name;
  13.     this.email = email;
  14.   }
  16.   setTaxData(ssn, salary) {
  17.     this.taxData = new EmployeeTaxData(ssn, salary);
  18.   }
  19.   // ...
  20. }