• S(single)-单一职责原则- 一个程序只做好一件事；如果功能过于复杂就拆分开，每个部分保持独立；
  • O(open-close)-开放封闭原则- 对扩展开放，对修改封闭；增加需求时，扩展新代码，而非修改已有代码；
  • L(Liskov)-里氏置换原则-子类能覆盖父类；父类能出现的地方子类就能出现；
  • I(Interface)-接口独立原则-保持接口的单一独立，避免出现”胖接口“；js中没有接口（typescript除外），使用少；
  • D(Dependence)-依赖倒置原则-编程依赖抽象接口，不要依赖具体实现；使用方只关注接口而不关注具体类的实现；

1.单一职责原则

一个方法负责一项职责，只能有一项引起函数变化的原因
当一个函数用来处理多个事件时，我们需要对其进行分离，便于增加函数的可读性，方便对函数进行扩充。例如：当我们异步加载图片时

  1. // 单一职责原则：
  2. // const fs = require('fs')
  3. class Joyral {
  4.     constructor() {
  5.         this.entries = {}
  6.     }
  7.     addEvent(text) {
  8.         let count = ++Joyral.count
  9.         let entry = `${count}:${text}`
  10.         this.entries[count] = entry
  11.         return count
  12.     }
  13.     removeEntry(index) {
  14.         delete this.entries[index]
  15.     }
  16.     toObject() {
  17.         return this.entries
  18.     }
  19. }
  20. Joyral.count = 0
  21. let joyral = new Joyral()
  22. joyral.addEvent('今天早上吃了面条')
  23. joyral.addEvent('今天中午吃了米饭')
  24. console.log(joyral.toObject())

2.开放封闭原则

思想：当需要改变一个程序的功能或者给这个程序增加新功能的时候，可以使用增加代码的方式，但是不允许改动程序的源代码。

  1. let Color = Object.freeze({
  2.     red: 'red',
  3.     green: 'green',
  4.     blue: 'blue'
  5. })
  6. let Size = Object.freeze({
  7.     small: 'small',
  8.     medium: 'medium',
  9.     large: 'large'
  10. })
  12. class Product {
  13.     constructor(name, color, size) {
  14.         this.name = name
  15.         this.color = color
  16.         this.size = size
  17.     }
  18. }
  20. class ProductFilter {
  21.     filterBycolor(products, color) {
  22.         return products.filter((p) => p.color === color)
  23.     }
  24.     filterBySize(products, size) {
  25.         return products.filter((p) => p.color === size)
  26.     }
  27.     filterBySizeAndColor(products, size, color) {
  28.         return products.filter((p) => p.size === size && p.color === color)
  29.     }
  30.     // 如果还有不同的功能需要挨个添加
  31. }
  33. // 颜色规格
  34. class ColorSpecification {
  35.     constructor(color) {
  36.         this.color = color
  37.     }
  38.     isSatisfied(item) {
  39.         return item.color === this.color
  40.     }
  41. }
  43. // 尺寸规格
  44. class SizeSpecifcation {
  45.     constructor(size) {
  46.         this.size = size
  47.     }
  48.     isSatisfied(item) {
  49.         return item.size === this.size
  50.     }
  51. }
  53. class AndSpecification {
  54.     constructor(...specs) {
  55.         this.specs = specs
  56.     }
  57.     isSatisfied(item) {
  58.         return this.specs.every((x) => x.isSatisfied(item))
  59.     }
  60. }
  61. let apple = new Product('Apple', Color.green, Size.small)
  62. let tree = new Product('Tree', Color.green, Size.large)
  63. let house = new Product('House', Color.blue, Size.large)
  65. let products = [apple, tree, house]
  67. let pf = new ProductFilter()
  68. console.log('绿色的产品有(老)：')
  69. for (let p of pf.filterBycolor(products, Color.green)) {
  70.     console.log(`${p.name}是绿色的`)
  71. }
  73. class BetterFilter {
  74.     filter(items, spec) {
  75.         return items.filter((x) => spec.isSatisfied(x))
  76.     }
  77. }
  78. let bf = new BetterFilter()
  79. console.log('绿色的产品有（新）：')
  80. for (let p of bf.filter(products, new ColorSpecification(Color.green))) {
  81.     console.log(`${p.name} 是绿色的`)
  82. }
  84. console.log('既大又绿的产品：')
  85. let spec = new AndSpecification(new ColorSpecification(Color.green), new SizeSpecifcation(Size.large))
  86. for (let p of bf.filter(products, spec)) {
  87.     console.log(`${p.name} 是大的还是绿色的`)
  88. }