什么是建造者模式？

建造者模式（Builder Pattern）是一种创建型设计模式，它将复杂对象的构建过程与表示分离，使得同样的构建过程可以创建不同的表示。

其核心思想是：将复杂对象的创建步骤分解为多个独立的 “建造步骤”，由专门的 “建造者” 负责实现这些步骤，再由 “指挥者” 控制建造步骤的执行顺序，最终构建出完整对象。这样既可以灵活定制对象的各个部分，又能保证构建过程的规范性。

建造者模式的核心角色

1. 产品（Product）：被构建的复杂对象（如一台电脑、一份套餐）。
2. 抽象建造者（Builder）：定义构建产品的抽象步骤（如 “构建 CPU”“构建内存”），声明返回产品的方法。
3. 具体建造者（ConcreteBuilder）：实现抽象建造者的步骤，负责具体部件的创建和组装，最终返回具体产品。
4. 指挥者（Director）：接收建造者对象，控制建造步骤的执行顺序（如 “先构建 CPU，再构建内存”），不直接参与对象创建，只负责流程调度。

JavaScript 实现建造者模式示例：自定义电脑组装

以下以 “电脑组装” 为例，实现建造者模式。场景是：用户可定制电脑的 CPU、内存、硬盘等部件，不同配置（如 “办公电脑”“游戏电脑”）的部件选择和组装流程不同，但整体构建步骤一致（选 CPU→选内存→选硬盘→组装）。

代码实现 - javascript

// -------------- 1. 产品（Product）：电脑 --------------
class Computer {
  constructor() {
    this.parts = {}; // 存储电脑部件（CPU、内存、硬盘等）
  }

  // 添加部件
  addPart(name, value) {
    this.parts[name] = value;
  }

  // 展示电脑配置
  show() {
    console.log("电脑配置：");
    Object.entries(this.parts).forEach(([part, value]) => {
      console.log(`- ${part}：${value}`);
    });
  }
}

// -------------- 2. 抽象建造者（Builder）：电脑建造接口 --------------
class ComputerBuilder {
  constructor() {
    this.computer = new Computer(); // 初始化产品
  }

  // 抽象步骤：构建CPU（由子类实现）
  buildCPU() {
    throw new Error("子类必须实现 buildCPU 方法");
  }

  // 抽象步骤：构建内存
  buildMemory() {
    throw new Error("子类必须实现 buildMemory 方法");
  }

  // 抽象步骤：构建硬盘
  buildHardDisk() {
    throw new Error("子类必须实现 buildHardDisk 方法");
  }

  // 返回构建好的产品
  getResult() {
    return this.computer;
  }
}

// -------------- 3. 具体建造者：办公电脑建造者 --------------
class OfficeComputerBuilder extends ComputerBuilder {
  buildCPU() {
    this.computer.addPart("CPU", "Intel i5（办公级）");
  }

  buildMemory() {
    this.computer.addPart("内存", "16GB DDR4");
  }

  buildHardDisk() {
    this.computer.addPart("硬盘", "512GB SSD");
  }
}

// -------------- 4. 具体建造者：游戏电脑建造者 --------------
class GamingComputerBuilder extends ComputerBuilder {
  buildCPU() {
    this.computer.addPart("CPU", "Intel i9（旗舰级）");
  }

  buildMemory() {
    this.computer.addPart("内存", "64GB DDR5");
  }

  buildHardDisk() {
    this.computer.addPart("硬盘", "2TB SSD");
  }
}

// -------------- 5. 指挥者（Director）：控制建造流程 --------------
class Director {
  // 接收建造者，按顺序执行建造步骤
  construct(builder) {
    builder.buildCPU(); // 第一步：构建CPU
    builder.buildMemory(); // 第二步：构建内存
    builder.buildHardDisk(); // 第三步：构建硬盘
  }
}

// -------------- 6. 客户端使用 --------------
// 创建指挥者
const director = new Director();

// 构建办公电脑
const officeBuilder = new OfficeComputerBuilder();
director.construct(officeBuilder); // 指挥者控制流程
const officeComputer = officeBuilder.getResult();
officeComputer.show();
// 输出：
// 电脑配置：
// - CPU：Intel i5（办公级）
// - 内存：16GB DDR4
// - 硬盘：512GB SSD

// 构建游戏电脑
const gamingBuilder = new GamingComputerBuilder();
director.construct(gamingBuilder); // 复用相同的流程
const gamingComputer = gamingBuilder.getResult();
gamingComputer.show();
// 输出：
// 电脑配置：
// - CPU：Intel i9（旗舰级）
// - 内存：64GB DDR5
// - 硬盘：2TB SSD

代码说明

1. 产品（Computer）：表示被构建的复杂对象，通过 addPart 方法存储部件，show 方法展示最终配置。
2. 抽象建造者（ComputerBuilder）：定义了构建电脑的三个核心步骤（buildCPU、buildMemory、buildHardDisk），并提供 getResult 方法返回产品，规范了建造者的接口。
3. 具体建造者（OfficeComputerBuilder 等）：实现抽象建造者的步骤，根据自身类型（办公 / 游戏）选择具体部件（如办公电脑用 i5 CPU，游戏电脑用 i9 CPU）。
4. 指挥者（Director）：负责控制建造流程的顺序（先 CPU→再内存→再硬盘），与具体建造者解耦，确保所有电脑都遵循相同的构建步骤。
5. 客户端：只需选择具体建造者（如 OfficeComputerBuilder），通过指挥者完成构建，无需关心步骤细节，即可获得定制化产品。

建造者模式的优势

• 灵活定制：通过不同的具体建造者，可在相同构建流程下创建不同配置的产品（如办公电脑 vs 游戏电脑）。
• 解耦构建与表示：建造步骤（如何构建）与产品表示（最终样子）分离，修改产品配置只需换建造者，无需改流程。
• 控制细节：将复杂对象的创建拆分为独立步骤，便于管理每个部件的构建逻辑，降低复杂度。

与工厂模式的区别

简化实现（无指挥者）

在简单场景下，可省略指挥者，由客户端直接调用建造者的步骤（适合需要灵活调整步骤顺序的场景）：

// 客户端直接控制步骤（省略指挥者）
const customBuilder = new GamingComputerBuilder();
customBuilder.buildHardDisk(); // 先装硬盘
customBuilder.buildCPU(); // 再装CPU（调整顺序）
customBuilder.buildMemory();
const customComputer = customBuilder.getResult();
customComputer.show();

建造者模式的核心是 “分步构建，定制细节”，特别适合创建结构复杂、配置多变的对象（如汽车、文档、表单等），在框架和库的设计中应用广泛（如 React 的 createElement 分步构建虚拟 DOM）。