JavaScript设计模式(四)——建造者模式：优雅构建复杂对象的实用指南

引言：理解建造者模式的价值

在JavaScript开发中，我们经常需要创建复杂对象，这些对象通常包含多个属性和嵌套结构。建造者模式（Builder）是一种创建型设计模式，它将复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。其核心思想是通过一步步构建复杂对象，避免构造函数参数过多或对象创建逻辑混乱。

当我们面对具有多个可选参数的复杂对象创建时，传统的构造函数方式会显得笨拙且难以维护。建造者模式通过链式调用和分步构建，使代码更加清晰、可读性更强。与工厂模式专注于创建产品不同，建造者模式更关注复杂对象的构建过程；与抽象工厂模式创建产品族相比，建造者模式则专注于构建单个复杂对象。

本文将带领读者深入理解JavaScript中的建造者模式，从基础概念到实际应用，逐步掌握这种优雅的复杂对象构建方法。我们将探讨建造者模式的实现原理、适用场景，并通过实际案例展示其在JavaScript项目中的最佳实践。通过学习本文，您将能够识别需要使用建造者模式的场景，并熟练运用它来简化复杂对象的创建过程，提升代码的可维护性和可扩展性。

建造者模式的核心概念与结构

建造者模式是一种创建型设计模式，它允许我们分步骤构建复杂对象，同时将构建过程与表示分离。想象一下组装一台电脑 - 你需要选择CPU、内存、硬盘等组件，然后按照特定顺序将它们组装起来。建造者模式就像是电脑组装指导手册，它规定了组装步骤，但不关心具体品牌和型号。

建造者模式包含四个核心角色：

1. 产品(Product): 最终构建的复杂对象，包含多个组成部分。
2. 抽象建造者(Builder): 定义构建产品的接口，包含创建和组装各个部件的方法。
3. 具体建造者(Concrete Builder): 实现抽象建造者接口，负责具体构建产品的各个部分。
4. 指挥者(Director): 使用建造者对象构建产品，控制构建流程。

建造者模式的工作流程是：首先创建一个指挥者和一个或多个具体建造者，然后指挥者调用建造者的方法逐步构建产品，最后从建造者中获取最终产品。

这种模式的主要优势在于分离关注点 - 将对象的构建过程与其表示分离，使得相同的构建过程可以创建不同的表示。同时，它也封装了复杂性，隐藏了对象创建的内部细节，使得客户端代码更加简洁。

让我们通过一个实际的代码示例来理解建造者模式：

// 产品：电脑
class Computer {
  constructor() {
    this.cpu = '';
    this.ram = '';
    this.storage = '';
    this.gpu = '';
  }
  
  toString() {
    return `Computer配置: CPU=${this.cpu}, RAM=${this.ram}, 存储=${this.storage}, GPU=${this.gpu}`;
  }
}

// 抽象建造者
class ComputerBuilder {
  constructor() {
    this.computer = new Computer();
  }
  
  // 设置CPU
  setCpu(cpu) {
    this.computer.cpu = cpu;
    return this; // 支持链式调用
  }
  
  // 设置内存
  setRam(ram) {
    this.computer.ram = ram;
    return this;
  }
  
  // 设置存储
  setStorage(storage) {
    this.computer.storage = storage;
    return this;
  }
  
  // 设置显卡
  setGpu(gpu) {
    this.computer.gpu = gpu;
    return this;
  }
  
  // 获取构建好的电脑
  getResult() {
    return this.computer;
  }
}

// 具体建造者：游戏电脑
class GamingComputerBuilder extends ComputerBuilder {
  constructor() {
    super();
    this.computer = new Computer();
  }
  
  // 构建游戏专用电脑
  build() {
    this.setCpu('Intel i9')
       .setRam('32GB DDR4')
       .setStorage('1TB NVMe SSD')
       .setGpu('RTX 3080');
    return this.getResult();
  }
}

// 具体建造者：办公电脑
class OfficeComputerBuilder extends ComputerBuilder {
  constructor() {
    super();
    this.computer = new Computer();
  }
  
  // 构建办公专用电脑
  build() {
    this.setCpu('Intel i5')
       .setRam('16GB DDR4')
       .setStorage('512GB SSD')
       .setGpu('集成显卡');
    return this.getResult();
  }
}

// 指挥者
class ComputerDirector {
  constructor(builder) {
    this.builder = builder;
  }
  
  // 指挥建造者构建电脑
  construct() {
    return this.builder.build();
  }
}

// 使用建造者模式构建电脑
const gamingBuilder = new GamingComputerBuilder();
const officeBuilder = new OfficeComputerBuilder();

const gamingDirector = new ComputerDirector(gamingBuilder);
const officeDirector = new ComputerDirector(officeBuilder);

const gamingComputer = gamingDirector.construct();
const officeComputer = officeDirector.construct();

console.log(gamingComputer.toString());
console.log(officeComputer.toString());

预期输出结果：

Computer配置: CPU=Intel i9, RAM=32GB DDR4, 存储=1TB NVMe SSD, GPU=RTX 3080
Computer配置: CPU=Intel i5, RAM=16GB DDR4, 存储=512GB SSD, GPU=集成显卡

在这个例子中，我们通过不同的建造者创建了不同配置的电脑，而指挥者控制了构建流程。客户端代码无需了解电脑的具体构建细节，只需要调用建造者的方法即可得到所需产品。

JavaScript中的建造者模式实现

建造者模式是一种创建型设计模式，它允许你分步骤创建复杂对象，而无需关心其内部构造细节。这种模式特别适用于需要多种配置选项或构建步骤的场景。

基础实现（ES5语法）

// 建造者类 - 负责构建汉堡对象
function BurgerBuilder() {
  this.size = null;
  this.cheese = false;
  this.bacon = false;
  this.lettuce = false;
  this.tomato = false;
}

// 设置汉堡大小
BurgerBuilder.prototype.setSize = function(size) {
  this.size = size;
  return this; // 返回this以支持方法链
};

// 添加配料
BurgerBuilder.prototype.addCheese = function() {
  this.cheese = true;
  return this;
};

BurgerBuilder.prototype.addBacon = function() {
  this.bacon = true;
  return this;
};

// 构建最终汉堡对象
BurgerBuilder.prototype.build = function() {
  return {
    size: this.size,
    cheese: this.cheese,
    bacon: this.bacon,
    lettuce: this.lettuce,
    tomato: this.tomato
  };
};

// 使用示例
var burger = new BurgerBuilder()
  .setSize('large')
  .addCheese()
  .addBacon()
  .build();

现代JavaScript实现（ES6+）

class BurgerBuilder {
  constructor() {
    this.size = 'medium';
    this.cheese = false;
    this.bacon = false;
    this.lettuce = false;
    this.tomato = false;
  }

  setSize(size = 'medium') {
    this.size = size;
    return this; // **方法链式调用**的关键
  }

  addCheese() {
    this.cheese = true;
    return this;
  }

  build() {
    return {
      size: this.size,
      cheese: this.cheese,
      bacon: this.bacon,
      lettuce: this.lettuce,
      tomato: this.tomato
    };
  }
}

// 使用示例
const burger = new BurgerBuilder()
  .setSize('large')
  .addCheese()
  .build();

异步建造者模式

class AsyncUserBuilder {
  constructor() {
    this.id = null;
    this.name = null;
    this.email = null;
  }

  setId(id) {
    this.id = id;
    return this;
  }

  // 异步加载数据
  async loadUserData() {
    const response = await fetch(`/api/users/${this.id}`);
    const data = await response.json();
    
    this.name = data.name;
    this.email = data.email;
    
    return this; // 保持方法链
  }

  build() {
    return {
      id: this.id,
      name: this.name,
      email: this.email
    };
  }
}

// 使用示例
async function createUser() {
  const user = await new AsyncUserBuilder()
    .setId(123)
    .loadUserData()
    .build();
  
  console.log(user); // {id: 123, name: "John", email: "john@example.com"}
}

建造者模式就像一个自助餐厅，你可以按照自己的喜好选择不同的菜品（属性），最后组合成一顿完整的餐点（复杂对象）。这种方法使对象的构建过程更加灵活、可读，并且易于维护。

建造者模式的应用场景分析

建造者模式是一种创建型设计模式，它将复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。在JavaScript中，建造者模式特别适用于以下场景：

复杂对象的创建

当需要创建具有多个可选参数的对象时，使用构造函数参数列表会变得冗长且难以维护。建造者模式允许我们按需设置参数，避免"参数地狱"。

// 复杂对象示例 - 一台电脑
class Computer {
  constructor() {
    this.ram = ''; // 内存
    this.hdd = ''; // 硬盘
    this.gpu = ''; // 显卡
    this.cpu = ''; // 处理器
    this.os = '';  // 操作系统
  }
}

// **建造者类** - 负责构建复杂对象
class ComputerBuilder {
  constructor() {
    this.computer = new Computer();
  }
  
  // 设置内存
  setRam(ram) {
    this.computer.ram = ram;
    return this; // **链式调用** - 返回this以支持连续调用
  }
  
  // 设置硬盘
  setHdd(hdd) {
    this.computer.hdd = hdd;
    return this;
  }
  
  // 设置显卡
  setGpu(gpu) {
    this.computer.gpu = gpu;
    return this;
  }
  
  // 设置处理器
  setCpu(cpu) {
    this.computer.cpu = cpu;
    return this;
  }
  
  // 设置操作系统
  setOs(os) {
    this.computer.os = os;
    return this;
  }
  
  // 构建最终对象
  build() {
    return this.computer;
  }
}

// 使用建造者模式创建电脑
const gamingComputer = new ComputerBuilder()
  .setRam('16GB')
  .setHdd('1TB SSD')
  .setGpu('RTX 3080')
  .setCpu('Intel i7')
  .setOs('Windows 11')
  .build();

console.log(gamingComputer);
// 输出: Computer { ram: '16GB', hdd: '1TB SSD', gpu: 'RTX 3080', cpu: 'Intel i7', os: 'Windows 11' }

多种表示形式的对象

建造者模式可以轻松创建不同配置或表示的对象，而无需修改核心构建逻辑。

// 创建办公电脑
const officeComputer = new ComputerBuilder()
  .setRam('8GB')
  .setHdd('256GB SSD')
  .setCpu('Intel i5')
  .setOs('Windows 10')
  .build();

console.log(officeComputer);
// 输出: Computer { ram: '8GB', hdd: '256GB SSD', gpu: '', cpu: 'Intel i5', os: 'Windows 10' }

步骤化的构建过程

对于需要按特定顺序和条件构建的对象，建造者模式提供了清晰的构建流程。

// 步骤化构建示例 - 配置一辆汽车
class Car {
  constructor() {
    this.brand = '';
    this.model = '';
    this.engine = '';
    this.transmission = '';
    this.color = '';
    this.features = [];
  }
}

class CarBuilder {
  constructor() {
    this.car = new Car();
  }
  
  // 设置品牌
  setBrand(brand) {
    this.car.brand = brand;
    return this;
  }
  
  // 设置型号
  setModel(model) {
    this.car.model = model;
    return this;
  }
  
  // 设置发动机
  setEngine(engine) {
    this.car.engine = engine;
    return this;
  }
  
  // 设置变速箱
  setTransmission(transmission) {
    this.car.transmission = transmission;
    return this;
  }
  
  // 设置颜色
  setColor(color) {
    this.car.color = color;
    return this;
  }
  
  // 添加特性
  addFeature(feature) {
    this.car.features.push(feature);
    return this;
  }
  
  // 构建最终对象
  build() {
    // **验证逻辑** - 确保必要字段已设置
    if (!this.car.brand || !this.car.model) {
      throw new Error('Brand and model are required');
    }
    return this.car;
  }
}

// 步骤化构建汽车
const sportsCar = new CarBuilder()
  .setBrand('Porsche')
  .setModel('911')
  .setEngine('3.0L H6')
  .setTransmission('PDK')
  .setColor('Red')
  .addFeature('Sport Chrono Package')
  .addFeature('Sports Exhaust')
  .build();

console.log(sportsCar);
// 输出: Car {
//   brand: 'Porsche',
//   model: '911',
//   engine: '3.0L H6',
//   transmission: 'PDK',
//   color: 'Red',
//   features: ['Sport Chrono Package', 'Sports Exhaust']
// }

配置对象的构建

对于具有复杂配置的对象，建造者模式可以提供清晰的配置接口。

// 复杂配置示例 - API请求
class APIRequest {
  constructor() {
    this.method = 'GET';
    this.url = '';
    this.headers = {};
    this.params = {};
    this.data = null;
    this.timeout = 0;
    this.withCredentials = false;
  }
}

class APIRequestBuilder {
  constructor() {
    this.request = new APIRequest();
  }
  
  // 设置HTTP方法
  setMethod(method) {
    this.request.method = method.toUpperCase();
    return this;
  }
  
  // 设置URL
  setUrl(url) {
    this.request.url = url;
    return this;
  }
  
  // 设置请求头
  setHeader(key, value) {
    this.request.headers[key] = value;
    return this;
  }
  
  // 设置查询参数
  setParam(key, value) {
    this.request.params[key] = value;
    return this;
  }
  
  // 设置请求体数据
  setData(data) {
    this.request.data = data;
    return this;
  }
  
  // 设置超时时间
  setTimeout(timeout) {
    this.request.timeout = timeout;
    return this;
  }
  
  // 设置是否携带凭证
  withCredentials(flag) {
    this.request.withCredentials = flag;
    return this;
  }
  
  // 构建最终对象
  build() {
    if (!this.request.url) {
      throw new Error('URL is required');
    }
    return this.request;
  }
}

// 构建复杂的API请求
const apiRequest = new APIRequestBuilder()
  .setMethod('POST')
  .setUrl('https://api.example.com/users')
  .setHeader('Content-Type', 'application/json')
  .setHeader('Authorization', 'Bearer token123')
  .setParam('page', 1)
  .setParam('limit', 20)
  .setData({ name: 'John Doe', email: 'john@example.com' })
  .setTimeout(5000)
  .withCredentials(true)
  .build();

console.log(apiRequest);
// 输出: APIRequest {
//   method: 'POST',
//   url: 'https://api.example.com/users',
//   headers: {
//     'Content-Type': 'application/json',
//     'Authorization': 'Bearer token123'
//   },
//   params: { page: 1, limit: 20 },
//   data: { name: 'John Doe', email: 'john@example.com' },
//   timeout: 5000,
//   withCredentials: true
// }

建造者模式通过将复杂对象的构建过程分解为多个步骤，使得代码更加清晰、可维护，并且提供了极大的灵活性。无论是处理具有多个可选参数的对象，还是需要构建具有复杂配置的对象，建造者模式都能提供优雅的解决方案。

建造者模式的优缺点分析

建造者模式作为创建型设计模式，在实际开发中具有显著的价值，但也存在一定的局限性。下面我们从多个维度对其进行深入分析。

优点分析

提高代码可读性：建造者模式将复杂对象的构建过程分解为多个步骤，使代码逻辑更加清晰。例如，构建一个复杂的计算机配置：

// 建造者模式示例 - 逐步构建复杂对象
class ComputerBuilder {
  constructor() {
    this.computer = {}; // 初始化产品对象
  }
  
  // **重要概念**: 链式调用方法
  setCPU(cpu) {
    this.computer.cpu = cpu;
    return this; // 返回this以支持链式调用
  }
  
  setRAM(ram) {
    this.computer.ram = ram;
    return this;
  }
  
  setGPU(gpu) {
    this.computer.gpu = gpu;
    return this;
  }
  
  build() {
    return this.computer;
  }
}

// 使用建造者模式创建计算机
const gamingPC = new ComputerBuilder()
  .setCPU('Intel i9')
  .setRAM('32GB')
  .setGPU('RTX 3080')
  .build();

console.log(gamingPC);
// 预期输出: { cpu: 'Intel i9', ram: '32GB', gpu: 'RTX 3080' }

封装复杂性：建造者模式将构建逻辑与表示分离，客户端无需了解构建细节。

增强灵活性：可以创建不同表示的对象，而不改变其构建过程。

缺点分析

增加代码复杂度：对于简单对象，使用建造者模式可能导致过度设计。例如：

// 简单对象使用建造者模式 - 过度设计
class SimplePointBuilder {
  constructor() {
    this.point = { x: 0, y: 0 };
  }
  
  setX(x) {
    this.point.x = x;
    return this;
  }
  
  setY(y) {
    this.point.y = y;
    return this;
  }
  
  build() {
    return this.point;
  }
}

// 这种简单场景直接创建对象更合适
const point = { x: 10, y: 20 };

性能考量

建造者模式引入了额外的对象创建和调用开销，但在大多数应用场景中，这种开销可以忽略不计。关键在于权衡代码可维护性与性能需求。

适用性分析

选择建造者模式的情况：

• 需要创建复杂对象
• 需要分步骤构建对象
• 需要不同表示的对象
• 构建过程需要独立于组件

选择其他模式的情况：

• 对象简单（直接使用工厂模式或简单构造函数）
• 创建过程不需要分步骤
• 不需要多种表示

建造者模式的价值在于它平衡了代码的可读性、可维护性和灵活性，适用于构建复杂对象的场景，但对简单对象可能显得过度设计。

建造者模式的高级变种

在掌握了基本的建造者模式后，我们可以探索几种高级变种，它们能进一步提升代码的灵活性和可读性。

流式建造者模式

流式建造者模式通过方法链提供更流畅的API设计。就像一位厨师有条不紊地准备菜肴，每个步骤完成后都能继续下一步操作。

class FluentComputerBuilder {
  constructor() {
    this.computer = {};
  }
  
  // 设置处理器并返回this以支持链式调用
  setProcessor(processor) {
    this.computer.processor = processor;
    return this; // 关键：返回this对象
  }
  
  setRam(ram) {
    this.computer.ram = ram;
    return this;
  }
  
  build() {
    return this.computer;
  }
}

// 使用流式建造者
const gamingPC = new FluentComputerBuilder()
  .setProcessor('Intel i9')
  .setRam('32GB')
  .build();

console.log(gamingPC); // 输出: { processor: 'Intel i9', ram: '32GB' }

参数化建造者模式

参数化建造者模式通过参数控制构建过程，就像一位可以根据不同需求定制产品的工匠。

class ParameterizedComputerBuilder {
  constructor() {
    this.computer = {};
  }
  
  // 根据参数类型设置不同的配置
  configure(type) {
    const configurations = {
      office: { processor: 'i5', ram: '16GB', gpu: '集成' },
      gaming: { processor: 'i7', ram: '32GB', gpu: 'RTX 3080' },
      server: { processor: 'Xeon', ram: '64GB', gpu: '无' }
    };
    
    this.computer = { ...configurations[type] };
    return this;
  }
  
  build() {
    return this.computer;
  }
}

// 使用参数化建造者
const officePC = new ParameterizedComputerBuilder()
  .configure('office')
  .build();

console.log(officePC); // 输出: { processor: 'i5', ram: '16GB', gpu: '集成' }

嵌套建造者模式

嵌套建造者模式用于构建包含其他复杂对象的复杂对象，如同组装一台精密仪器，每个部件本身也可能是一个复杂的组件。

class GPUBuilder {
  build() {
    return { model: 'RTX 3080', memory: '10GB' };
  }
}

class NestedComputerBuilder {
  constructor() {
    this.computer = {};
  }
  
  setProcessor(processor) {
    this.computer.processor = processor;
    return this;
  }
  
  // 嵌套GPU构建过程
  setGPU() {
    const gpuBuilder = new GPUBuilder();
    this.computer.gpu = gpuBuilder.build();
    return this;
  }
  
  build() {
    return this.computer;
  }
}

// 使用嵌套建造者
const highEndPC = new NestedComputerBuilder()
  .setProcessor('AMD Ryzen 9')
  .setGPU()
  .build();

console.log(highEndPC);
/* 输出:
{
  processor: 'AMD Ryzen 9',
  gpu: { model: 'RTX 3080', memory: '10GB' }
}
*/

缓存建造者

缓存建造者模式通过缓存已构建的对象来优化性能，避免重复创建相同的对象，就像一个聪明的仓库管理员，会记住常用物品的位置。

class CachedComputerBuilder {
  constructor() {
    this.computer = {};
    this.cache = new Map(); // 使用Map作为缓存存储
  }
  
  // 检查缓存中是否已有相同配置的计算机
  build(processor, ram) {
    const key = `${processor}-${ram}`;
    
    if (this.cache.has(key)) {
      console.log(`从缓存获取: ${key}`);
      return this.cache.get(key);
    }
    
    console.log(`创建新配置: ${key}`);
    this.computer = { processor, ram };
    this.cache.set(key, this.computer);
    return this.computer;
  }
}

// 使用缓存建造者
const builder = new CachedComputerBuilder();
const pc1 = builder.build('i7', '16GB');
const pc2 = builder.build('i7', '16GB'); // 从缓存获取
const pc3 = builder.build('i9', '32GB'); // 创建新配置

这些高级变种使建造者模式更加灵活，能够适应各种复杂场景，同时保持代码的清晰和可维护性。

实战案例：构建复杂UI组件

在构建复杂UI组件时，建造者模式能帮助我们优雅地处理组件的配置和初始化过程。让我们以一个可配置的卡片组件为例，展示如何应用建造者模式。

案例背景与需求分析

假设我们需要创建一个高度可配置的卡片组件，它包含标题、内容、图片、按钮等多种元素，并支持多种样式和行为配置。传统方式下，构造函数参数会变得异常复杂，难以维护。

实现过程

// 卡片组件类
class Card {
  constructor(builder) {
    this.title = builder.title;
    this.content = builder.content;
    this.image = builder.image;
    this.buttons = builder.buttons;
    this.styles = builder.styles;
  }
  
  render() {
    // 渲染卡片逻辑
    return `<div class="card ${this.styles}">
              <h2>${this.title}</h2>
              ${this.image ? `<img src="${this.image}" />` : ''}
              <p>${this.content}</p>
              <div class="buttons">
                ${this.buttons.map(btn => `<button>${btn}</button>`).join('')}
              </div>
            </div>`;
  }
}

// 建造者类
class CardBuilder {
  constructor() {
    this.reset();
  }
  
  // 重置状态
  reset() {
    this.title = '';
    this.content = '';
    this.image = '';
    this.buttons = [];
    this.styles = '';
    return this;
  }
  
  // 设置各个属性的方法
  setTitle(title) {
    this.title = title;
    return this;
  }
  
  setContent(content) {
    this.content = content;
    return this;
  }
  
  setImage(image) {
    this.image = image;
    return this;
  }
  
  addButtons(...buttons) {
    this.buttons.push(...buttons);
    return this;
  }
  
  setStyles(styles) {
    this.styles = styles;
    return this;
  }
  
  // 构建最终对象
  build() {
    const card = new Card(this);
    this.reset();
    return card;
  }
}

代码解析

建造者模式的核心 在于将复杂对象的构建与其表示分离。CardBuilder提供了链式调用的方法，每个方法都返回this，允许连续调用。这种方式使代码更加清晰和可读。

效果对比

传统方式：

// 参数过多，难以理解
const card1 = new Card('标题', '内容', 'img.jpg', ['按钮1', '按钮2'], 'card-style');

建造者方式：

// 清晰易读，可选择性配置
const card2 = new CardBuilder()
  .setTitle('用户信息')
  .setContent('这是用户详细信息')
  .setImage('avatar.jpg')
  .addButtons('编辑', '删除')
  .setStyles('user-card')
  .build();

建造者模式让我们能够以更灵活、可读的方式构建复杂对象，特别是在需要多种配置组合的场景下，优势尤为明显。通过链式调用，代码不仅更易维护，还能避免参数过多导致的混乱。

建造者模式的最佳实践

在JavaScript中有效使用建造者模式，遵循最佳实践至关重要。这不仅能使代码更易维护，还能提高团队协作效率。

命名约定 为建造者模式组件提供清晰的标识是首要任务。建议以"Builder"作为后缀，如HouseBuilder、CarBuilder，使代码意图一目了然。方法名应使用动词描述操作，如setRoof()、addWheel()。

// 命名约定示例
class PizzaBuilder {
  constructor() {
    this.pizza = { size: 'medium', toppings: [] };
  }
  
  // 使用动词描述的方法名
  addTopping(topping) {
    this.pizza.toppings.push(topping);
    return this; // 支持链式调用
  }
  
  build() {
    return this.pizza;
  }
}

错误处理在构建过程中尤为关键。应在构建方法中添加验证逻辑，确保对象完整性。

class ComputerBuilder {
  // ...其他方法
  
  build() {
    if (! this.cpu) {
      throw new Error('CPU must be specified');
    }
    return this.computer;
  }
}

可扩展性设计要求建造者采用模块化方法，便于添加新功能。通过组合而非继承实现扩展。

// 基础建造者
class MealBuilder {
  constructor() {
    this.meal = {};
  }
  
  // 基础构建方法
  // ...
}

// 扩展建造者 - 通过组合实现
class VeganMealBuilder extends MealBuilder {
  constructor() {
    super();
    this.meal = { type: 'vegan', ingredients: [] };
  }
  
  // 添加特定方法
  addQuinoa() {
    this.meal.ingredients.push('quinoa');
    return this;
  }
}

文档编写应包括建造者的使用示例、配置选项和可能的错误情况。JSDoc注释是理想选择：

/**
 * 创建一个复杂的UI组件
 * @param {Object} config - 组件配置
 * @param {string} config.title - 组件标题
 * @param {string} config.theme - 组件主题
 * @returns {UIComponent} 构建好的UI组件
 * @throws {Error} 当缺少必要配置时抛出错误
 */
class UIComponentBuilder {
  // ...
}

遵循这些最佳实践，你的建造者模式实现将更加健壮、可维护，并为团队提供清晰的代码结构。

总结与进阶学习

建造者模式通过将复杂对象的构建与表示分离，提供了优雅的对象创建方式。它特别适合处理具有多个组成部分的复杂对象，如配置对象、表单数据或UI组件。在实际开发中，建造者模式能显著提升代码可读性，遵循单一职责原则，并允许灵活地创建不同表示的对象。与工厂模式结合使用时，工厂负责创建简单对象，而建造者则专注于构建复杂对象；与组合模式结合，则能构建复杂的嵌套结构。在实际项目中，尝试使用建造者模式重构现有代码，特别是在创建复杂配置对象或设计API时，你会感受到它带来的代码整洁性和可维护性的提升。记住，好的设计模式不是过度使用的工具，而是解决特定问题的利器。