JavaScript工厂模式入门：用函数封装对象创建

JavaScript 设计模式

在 JavaScript 中，批量生成结构相同或相似的对象是常见需求。直接使用对象字面量会导致代码重复与修改困难，而工厂模式的核心做法非常直接：编写一个普通函数，在函数内部集中处理对象的组装与初始化逻辑，并将构造好的新对象作为返回值交付给调用者。本文将结合清晰的推导演进、完整代码示例与对比分析，带你系统掌握工厂模式的实现与适用边界。

一、认识痛点：为什么不要频繁使用字面量硬编码对象

在初学 JavaScript 时，我们通常使用对象字面量（{ ... }）来表示一个实体。例如，在权限管理系统中定义普通用户：

// 手工编写的用户字面量
const userAlice = {
  username: "Alice",
  role: "member",
  permissions: ["read"],
  showProfile() {
    console.log(`用户: ${this.username}, 角色: ${this.role}`);
  }
};

const userBob = {
  username: "Bob",
  role: "member",
  permissions: ["read"],
  showProfile() {
    console.log(`用户: ${this.username}, 角色: ${this.role}`);
  }
};

这种写法直观但存在明显的工程隐患：

• 冗余重复度高：每个对象的属性结构、默认权限和 showProfile 打印方法被原样复制了一遍，代码体积随着实例增多而线性膨胀。
• 维护成本脆弱：若业务要求为所有用户新增 status: "active" 属性或调整 showProfile 格式，开发者必须逐个定位并修改所有字面量，极易出现遗漏。
• 缺乏参数校验与契约：调用方可以直接随意传入缺失字段的对象，无法在创建节点形成统一的约束拦截。

二、核心机制：三步构建标准工厂函数

所谓工厂模式（Factory Pattern），就是像现实世界的制造流水线一样，把生产对象的“模具”与“流程”固定在函数内。外部调用端无需过问对象具体是如何拼装出来的，只要按需传入必要参数即可。

构建一个标准工厂函数遵循以下三步：

步骤 1：定义接收基础参数的函数

提取出对象之间真正存在差异的动态数据（例如用户名、邮箱、自定义角色等），作为工厂函数的入参：

function createUser(username, role = "member") {
  // 步骤 1：接收外部差异参数，并可做校验
  if (!username) {
    throw new Error("用户名不可为空");
  }
  // ...
}

步骤 2：在内部声明新对象并装配属性与方法

在函数执行上下文中新建一个对象，将外部入参与通用字段、默认方法集中绑定在一起：

function createUser(username, role = "member") {
  if (!username) throw new Error("用户名不可为空");

  // 步骤 2：集中组装对象属性与能力
  const user = {
    username,
    role,
    createdAt: new Date().toISOString(),
    permissions: role === "admin" ? ["read", "write", "delete"] : ["read"],
    showProfile() {
      console.log(`[${this.role.toUpperCase()}] ${this.username} (创建于 ${this.createdAt})`);
    }
  };

  // 步骤 3：返回组装完毕的对象
  return user;
}

步骤 3：调用端直接调用，获取纯净实例

此时使用该对象的业务代码彻底简化，且不再需要调用 new 运算符：

// 业务消费端
const tom = createUser("Tom");
const jerry = createUser("Jerry", "admin");

tom.showProfile();   // [MEMBER] Tom (创建于 2026-10-31T...)
jerry.showProfile(); // [ADMIN] Jerry (创建于 2026-10-31T...)

三、进阶优势：利用闭包保护对象内部私有状态

普通对象字面量或传统类公开属性很容易被外部意外篡改。例如 tom.role = "super_admin" 可以随时破坏既定状态。

工厂模式得益于 JavaScript 函数的闭包（Closure）机制，可以在函数内声明局部变量，并通过返回的方法形成外部访问管道，实现真正意义上的私有数据隔离：

// 带有私有变量保护的工厂函数
function createSecureUser(initialName, initialPassword) {
  // 私有变量：仅在 createSecureUser 作用域内存在，外界无法通过实例直接读写
  let passwordHash = hash(initialPassword);
  let failedLoginAttempts = 0;

  function hash(str) {
    return `hash_of_${str}`;
  }

  // 返回公开接口对象
  return {
    username: initialName,
    
    // 公开验证方法：间接与私有状态交互
    verifyPassword(inputPassword) {
      if (failedLoginAttempts >= 3) {
        console.warn("账户已被锁定，请联系管理员");
        return false;
      }

      if (hash(inputPassword) === passwordHash) {
        failedLoginAttempts = 0;
        return true;
      } else {
        failedLoginAttempts += 1;
        console.warn(`密码错误，当前剩余重试次数: ${3 - failedLoginAttempts}`);
        return false;
      }
    },

    // 安全重置密码
    changePassword(oldPwd, newPwd) {
      if (this.verifyPassword(oldPwd)) {
        passwordHash = hash(newPwd);
        console.log("密码更新成功");
        return true;
      }
      return false;
    }
  };
}

// 验证私有变量有效性
const account = createSecureUser("Carol", "secret123");
console.log(account.username);         // "Carol"
console.log(account.passwordHash);     // undefined (外部完全拿不到私有变量)
console.log(account.verifyPassword("wrong")); // 密码错误，当前剩余重试次数: 2
console.log(account.verifyPassword("secret123")); // true

在上述代码中，passwordHash 和 failedLoginAttempts 从外部直接访问全为 undefined，只能通过严格受控的方法进行修改。这种“硬件级”的封装在 JavaScript 模块开发中极为可靠。

四、方案对比：工厂模式 vs 构造函数 vs ES6 Class

初学者常常困惑：JavaScript 已经有了 new Constructor() 和 ES6 引入的 class 语法，为什么还需要用工厂函数？我们通过横向对比看清本质差异：

关于方法内存分配的关键权衡

必须客观认识工厂模式的物理代价：如果工厂函数中定义了普通方法，每次调用 createUser() 时，JavaScript 引擎都会在堆内存中重新申请一块空间存储该函数的指令闭包。如果页面中需要同时驻留几万个高频对象实例，这会带来额外的内存消耗。

相比之下，ES6 Class 或构造函数将通用方法挂载到 prototype 上，一万个实例也只共享同一处方法内存。

五、选型决策：什么时候用工厂模式？

工程选型没有绝对的优劣，只有对当下场景的适配权衡。

强烈推荐使用工厂模式的场景：

1. 轻量级或中等规模实体：页面上的 UI 组件配置、表单验证器、通用工具对象等。在这些场景中，实例数量通常只有几十到几百个，闭包开销完全在现代引擎毫秒级处理能力之内。
2. 需要彻底杜绝属性被篡改：例如令牌管理、支付流水凭证、包含敏感算法状态的计算器，闭包带来的安全性胜过原型链便利。
3. 对外提供公共库 SDK 接口：调用方不希望关心你的内部继承结构，也不想因为忘记写 new 导致异常，提供一个 createClient(config) 体验更平滑。
4. 规避 this 丢失问题：在 React Hooks 或事件监听场景中，对象方法经常作为回调函数传递。工厂返回的不依赖 this 的闭包函数可以直接解构（例如 const { verifyPassword } = account），永远不会出现 undefined is not an object (evaluating 'this.xxx') 的经典报错。

建议转向 ES6 Class 的场景：

1. 数以万计的数据模型实例：如大型富文本渲染节点、3D 渲染图元、微型数据流网格，必须依赖原型链以节约堆内存。
2. 深层类继承体系：需要清晰的多态、抽象类结构以及强类型的静态类型检查（如配合 TypeScript 的 instanceof 类型收窄）。

六、总结

JavaScript 工厂模式本质上是将“对象字面量的配置过程”装入“黑盒函数”中。它用最朴素自然的函数调用代替了冗长的手工初始化，以闭包机制赋予对象严密的私有性，以统一的返回值屏蔽了内部创建细节。

理解工厂模式不仅能提升日常代码的可维护性，更是迈向函数式编程与组件化设计的必经之路。在实际开发中，根据实例规模与封装需求，合理选用工厂函数与 ES6 Class，将让你的代码结构更加清晰、优雅且健壮。