将一个复杂对象分解为多个简单对象来进行构建，将复杂构建层和表现层分离，是的相同的构建过程可以创建不同的表现的模式

    建造者模式主要有4哥部分：product(产品类)、Builder(建造者类)、Director(指挥者类)、客户

    • 客户提出需求
    • 指挥者根据客户需求，指挥建造者去完成需求的各个部分
    • 建造者完成相应的部分

    产品类为一辆需要加工的空壳汽车

    1. class Car {
    2.     constructor() {
    3.     this.carName = ''
    4.     this.number = ''
    5.     this.wheel = ''
    6.     this.engine = ''
    7.   }
    8. }

    建造者类里有负责各个部分的工人，可以看到每个工人负责的事项

    1. class CarBuilder {
    2.   static nameBuilder(name) {
    3.       this.carName = name
    4.   }
    5.   static numberBuilder(number) {
    6.     this.number = number
    7.   }
    8.   static wheelBuilder(wheel) {
    9.       this.wheel = wheel
    10.   }
    11.   static engineBuilder(engine) {
    12.       this.engine = engine
    13.   }
    14.   static getCar(Car) {
    15.       const c = new Car()
    16.     c.carName = this.carName
    17.     c.number = this.number
    18.     c.wheel = this.wheel
    19.     c.engine = this.engine
    20.     return c
    21.   }
    22. }

    指挥者类，来指挥各个部分的工人以及他们的工作，他们各自的工作最终合并成一辆汽车

    1. class Director {
    2.   action(carInfo) {
    3.       CarBuilder.nameBuilder(carInfo.name)
    4.     CarBuilder.numberBuilder(carInfo.number)
    5.     CarBuilder.wheelBuilder(carInfo.wheel)
    6.     CarBuilder.engineBuilder(carInfo.engine)
    7.   }
    8. }

    使用指挥者建造一辆汽车

    1. const d = new Director()
    2. d.action({
    3.     name: "红旗",
    4.   number:"京A88888",
    5.   wheel: "五星轮毂",
    6.   engine: "V12发动机"
    7. })
    8. const c = CarBuilder.getCar(Car)
    9. console.log(c)
    10. // {"carName":"红旗","number":"京A88888","wheel":"五星轮毂","engine":"V12发动机"}