javascript设计模式学习之路

面向对象

概念

• 类，具备相同或类似属性或方法的对象的抽象就是类。例如：人都有姓名、年龄，都会吃饭、说话，其中姓名、年龄就是人这个类的属性，吃饭、说话就是人这个类的方法。
• 对象，类的具体实现就是对象。例如，小明这我的就能够认为是人这个类的具体实现。

示例代码：

// 类
class Person {
  constructor(name, age) {
    this.name = name // 属性 姓名
    this.age = age // 属性 年龄
  }
  // 方法 吃饭
  eat() {
    alert(`${this.name} eat something.`)
  }
  // 方法 说话
  speak() {
    alert(`My name is ${this.name}, my age is ${this.age}.`)
  }
}
// 对象 Person的具体实现
const xiaoming = new Person('xiaoming', 10)
xiaoming.eat()
xiaoming.speak()

三要素

• 继承，子类能够继承父类的属性和方法。例如，学生是人类的一种，具备人类的全部特性，也能够有本身的特性，能够认为学生继承了人这个父类。

class Person {
  constructor(name, age) {
    this.name = name
    this.age = age
  }
  eat() {
    alert(`${this.name} eat something.`)
  }
  speak() {
    alert(`My name is ${this.name}, my age is ${this.age}.`)
  }
}

// Student 继承了 Person，具备 Person 的全部属性，而且有本身的特有属性
class Student extends Person {
  constructor(name, age, no) {
    super(name, age)
    this.no = no // 学生能够有学号属性
  }
  // 学生能够学习
  study() {
    alert(`${this.name} study something.`)
  }
}

const xiaoming = new Student('xiaoming', 10, '10010')
xiaoming.study()

• 封装，类的属性具备访问权限。说到封装不得不说public、protected、private三个关键字，其中public关键字修饰的属性表示公有的属性，能够随便访问，protected关键字修饰的属性表示子类内部能够访问，private关键字修饰的属性只能在类内部访问，外部没法访问（图中+表示共有属性、#表示子类能够访问、-表示私有属性，因为 javascript 不支持这三种修饰符，因此此处用 typescript 演示，了解便可）。

class Person {
  public name // 公有属性，能够随便访问
  public age
  protected weight // 子类内部能够访问，外部没法访问
  constructor(name, age) {
    this.name = name
    this.age = age
    this.weight = 120
  }
  eat() {
    console.log(`${this.name} eat something.`)
  }
  speak() {
    console.log(`My name is ${this.name}, age is ${this.age}.`)
  }
}

class Student extends Person {
  private grilfriend // 私有属性，只有在 Student 类内部才能够访问
  constructor(name, age) {
    super(name, age)
    this.grilfriend = 'xiaoli'
  }
  study() {
    alert(`${this.name} study.`)
  }
  getWeight() {
    alert(`weight ${this.weight}.`) // protected 修饰的属性子类内部能够访问
  }
}

let xiaoming = new Student('xiaoming', 10)
xiaoming.getWeight()
alert(xiaoming.name)
// alert(xiaoming.weight) // 报错
// alert(xiaoming.grilfriend) // 报错

• 多态，子类既能够继承父类的属性和方法，也能够有本身的特性。学生是人类的一种，除了具备人类的全部特性以外，还能够有本身独特的特性，例如学生能够进行学习这个动做。

class Person {
  constructor(name) {
    this.name = name
  }
  saySomething() {}
}

class A extends Person {
  constructor(name) {
    super(name)
  }
  saySomething() {
    alert('This is A.')
  }
}

class B extends Person {
  constructor(name) {
    super(name)
  }
  saySomething() {
    alert('This is B.')
  }
}

五大设计原则

• 单一职责原则，应该有且只有一个引发变动的缘由，一个程序只作一件事情，若是功能过于复杂，就要拆开，每部分保持独立。
• 开放封闭原则，一个软件的实体，好比模块、类、对象应该对扩展开放，对修改封闭，增长新需求时要增长代码而不是修改代码。
• 里氏置换原则，只要父类出现的地方，子类就能够出现，且替换成子类也不会产生任何错误或者异常。
• 接口独立原则，创建单一接口，不要创建臃肿庞大的接口。即接口尽可能细化，同时接口中的方法尽可能少。
• 依赖倒置原则，面向接口编程，模块间的依赖关系经过接口和抽象类产生，实体类之间不直接发生依赖关系。
• 最少知识原则，为一个系统提供一个简单的入口，访问者或者客户不用了解系统内部的实现细节，只要懂得如何调用就好。

工厂模式

定义一个建立对象的工厂，将建立者和构造函数分离，建立者不用关心具体构造函数的实现，符合开放封闭原则和最少知识原则。

class Product {
  constructor(name) {
    this.name = name
  }
  init() {
    console.log('init.')
  }
  fn() {
    console.log('fn.')
  }
}

class Creator {
  create(name) {
    return new Product(name)
  }
}

const creator = new Creator()
const obj = creator.create('obj')
obj.init()
obj.fn()

单例模式

系统中被惟一使用，一个类只有一个示例，例如：

• 登陆框
• 购物车

class SingleObject {
  constructor() {}
  init() {
    console.log('init...')
  }
}

SingleObject.getInstance = (function() {
  let instance = null
  return function() {
    if (!instance) {
      instance = new SingleObject()
    }
    return instance
  }
})()

const obj1 = SingleObject.getInstance()
obj1.init()
const obj2 = SingleObject.getInstance()
obj2.init()
console.log(obj1 === obj2)