JS工厂模式与构造函数实例化对象怎么选

作者:半夏时间:2026-11-22 20:07:50浏览:640

从内存复用、类型识别、私有状态封装和多态返回四个核心差异出发,对比 JavaScript 工厂模式与构造函数实例化对象的适用边界,给出可落地的选型路径与组合写法。

核心判断依据:在 JavaScript 中创建结构相似的对象时,如果你需要批量创建带方法的实例、复用原型链以控制内存,或者依赖 instanceof 做类型识别,优先选构造函数(包括基于它的 ES6 class);如果你需要根据传入参数动态返回不同结构、依靠闭包彻底隐藏内部变量,或者不希望调用方关心 new 关键字,优先选工厂模式。

很多前端或 Node.js 开发者在写业务模块时都会遇到这个选择:同样是传几个参数返回一个带方法和状态的对象,写一个普通函数直接 return 对象,和写一个构造函数配合 new 实例化,到底差在哪里?下面先通过同一组可运行代码看清两者的真实差异,再按具体约束条件拆解选型方法。

JS工厂模式与构造函数实例化对象怎么选
缩略图:JavaScript 工厂模式与构造函数两种实例化机制的核心定位对比

先用同一段需求看懂两种写法

假设我们需要在项目中创建多个支付订单对象,每个订单都有订单金额 amount、支付渠道 channel,以及一个触发支付并打印状态的方法 pay()。下面分别用工厂模式和构造函数来实现这个需求。

以下代码可直接在 Node.js 18+ 或现代浏览器开发者工具控制台中运行:

// 1. 工厂模式:普通函数显式组装并返回对象
function createOrder(amount, channel) {
  const createdAt = Date.now(); // 通过闭包保存的内部时间,外部无法直接修改

  return {
    amount,
    channel,
    pay() {
      return `使用 ${channel} 支付 ${amount} 元(创建时间:${createdAt})`;
    }
  };
}

// 2. 构造函数模式:配合 new 与 prototype 共享方法
function Order(amount, channel) {
  this.amount = amount;
  this.channel = channel;
  this.createdAt = Date.now();
}

Order.prototype.pay = function () {
  return `使用 ${this.channel} 支付 ${this.amount} 元(创建时间:${this.createdAt})`;
};

const orderA = createOrder(120, 'wechat');
const orderB = new Order(120, 'alipay');

console.log(orderA.pay());
console.log(orderB.pay());
console.log('orderA instanceof Order:', orderA instanceof Order);
console.log('orderB instanceof Order:', orderB instanceof Order);
示例输出使用 wechat 支付 120 元(创建时间:1731350400000) 使用 alipay 支付 120 元(创建时间:1731350400001) orderA instanceof Order: false orderB instanceof Order: true

从运行结果能看到,表面上两个对象都能正常调用 pay(),但底层过程完全不同。需要补充说明的是,现代项目里常见的 ES6 class(如 class Order { constructor(...) {} pay() {} })在底层机制上依然属于构造函数加原型链这一类,只是把原型方法写进了类体里,并且强制要求使用 new 调用。

JS工厂模式与构造函数实例化对象怎么选
图1:工厂函数与构造函数在实例化时的四步执行流程差异

决定选型的四个核心差异

只看语法区别容易流于表面。在实际写项目时,真正影响你选工厂还是构造函数的,主要是下面四个工程层面的差异。

1. 内存占用与方法复用方式

工厂函数每调用一次,对象字面量里的方法(例如上面的 pay())就会重新创建一个新的函数对象。如果这个对象只是页面里的全局状态管理器、配置解析器,一共只创建一两个实例,多出来的几个函数引用几乎没有影响;但如果你要在画布里渲染 5000 个粒子节点,或者在长列表里封装上万条数据实体,工厂模式会让同样的逻辑函数在内存中重复分配上万份。

构造函数(或 class)把方法放在 prototype 上。无论你 new 出多少个实例,它们本身只保存各自的私有数据属性,方法统一通过原型链指针向上共享那一份函数体。

JS工厂模式与构造函数实例化对象怎么选
图2:工厂模式与构造函数在方法内存分配与原型指针上的区别
注意区分“实例方法”和“原型方法”:如果你在构造函数内部写 this.pay = function() {}(或者在 class 中写箭头函数字段 pay = () => {}),每个实例同样会复制一份函数,从而失去原型共享的内存优势。只有写在 prototype 上或 class 原型方法中的函数才会被所有实例共享。

2. 类型识别与多态返回能力

当后续代码需要判断“拿到的对象是不是某种类型”时,构造函数的优势非常直接:orderB instanceof Order 返回 true,框架或中间件也能读取 orderB.constructor.name。而工厂模式默认返回的是普通对象字面量,instanceof 只能识别到 Object。如果用工厂模式又想区分类型,通常需要额外约定 type 字段,或者靠鸭子类型检查对象是否具备某个方法。

反过来,工厂模式在动态返回不同结构和返回缓存实例时几乎没有限制。因为构造函数和 new 绑定在一起,调用 new Order() 的语义就是“创建一个 Order 实例”;而工厂函数可以根据传入参数决定返回微信支付处理器、银行卡支付处理器,甚至在命中连接池时直接返回一个已有的共享对象,调用方完全不需要改调用方式。

3. 私有状态的隐藏方式

如果你希望某个内部变量(例如计数器余额、重试次数或内部密钥)绝不允许外部代码直接读写,工厂模式利用 JavaScript 的函数作用域闭包就能做到真正的物理隔离。外面拿到的对象只能通过暴露出来的方法访问这些变量,根本摸不到变量引用本身。

传统构造函数如果要做类似隔离,把变量塞进构造函数闭包里,就必须把访问它的方法也定义在构造函数内部(回到每个实例复制方法的问题);挂在 this._createdAt 上又只是命名约定,外部照样能改。直到现代 ES2022 以后,class 才通过 #createdAt 私有字段语法补齐了既能放在原型方法里访问、又禁止外部读取的能力。如果项目还要考虑较灵活的闭包组合或老环境语法,工厂模式的闭包隔离依然更省心。

4. 调用安全与 this 指向风险

传统 function Order() 最大的一个隐患是漏写 new。在非严格模式下,直接调用 Order(120, 'alipay') 不会报错,而是把 this 指向全局对象(浏览器里的 window),悄悄污染全局变量并返回 undefined;在严格模式下则会直接抛出 TypeError。

工厂函数怎么调都是普通函数调用,永远不用担心漏写 new。更实际的好处是你可以直接把工厂函数传给数组方法或高阶函数,例如 rawList.map(createOrder);而构造函数如果不包一层箭头函数 rawList.map(item => new Order(item)),是没法直接作为回调传进去的。

按具体场景做选择:四步判断路径

把上面四个差异放进具体业务里,选型时可以按顺序问自己四个问题,不必死记优缺点表:

  1. 是否需要根据条件返回不同结构的对象,或复用已有缓存实例? 如果是(例如按配置类型生成不同校验器、按地址复用 WebSocket 连接),选工厂模式。
  2. 是否会批量生成大量带方法的同类对象,或需要用 instanceof / 继承体系? 如果是(例如数百个图表节点、游戏实体、业务领域模型),选构造函数 / class。
  3. 是否强依赖闭包隐藏私有状态,或经常把创建函数直接作为回调传递? 如果是(例如状态机、防抖/限流器、函数式数据转换),选工厂模式。
  4. 以上条件都不突出,只是封装少量简单配置或工具对象? 直接用工厂函数或普通对象字面量,结构更轻,省去类声明和 new 的样板代码。
JS工厂模式与构造函数实例化对象怎么选
图3:结合多态返回、实例规模与封装需求的四步选型判断流程

两者结合的实用写法与常见误区

在真实工程(尤其是公共工具库或 SDK)中,工厂模式和构造函数并不是非黑即白的选择。一个很常见的做法是:对外暴露工厂函数作为统一入口,内部根据参数去 new 不同的构造函数(或 class)。

这样做能同时解决两边的问题——调用方不需要记住各种子类的名字、也不用操心忘写 new,而返回的对象依然挂在原型链上,既节省内存,内部模块也能正常用 instanceof 做判断。下面的示例可在 Node.js 18+ 或浏览器控制台中运行:

// 内部使用 class(基于构造函数与原型)定义具体实现,共享方法并支持 instanceof
class BaseChannel {
  constructor(merchantId) {
    this.merchantId = merchantId;
  }
}

class AlipayChannel extends BaseChannel {
  pay(amount) {
    return `[支付宝] 商户 ${this.merchantId} 发起收款 ${amount} 元`;
  }
}

class CardChannel extends BaseChannel {
  pay(amount) {
    return `[银行卡] 商户 ${this.merchantId} 发起扣款 ${amount} 元`;
  }
}

// 对外暴露工厂函数:统一校验参数并按类型分发实例化
function createPaymentChannel(type, options = {}) {
  const merchantId = options.merchantId || 'DEFAULT_MCH';

  if (type === 'alipay') {
    return new AlipayChannel(merchantId);
  }
  if (type === 'card') {
    return new CardChannel(merchantId);
  }
  throw new Error(`不支持的支付渠道: ${type}`);
}

const channel1 = createPaymentChannel('alipay', { merchantId: 'M1001' });
const channel2 = createPaymentChannel('card', { merchantId: 'M1002' });

console.log(channel1.pay(88));
console.log(channel2.pay(199));
console.log('channel1 属于 BaseChannel:', channel1 instanceof BaseChannel);
示例输出[支付宝] 商户 M1001 发起收款 88 元 [银行卡] 商户 M1002 发起扣款 199 元 channel1 属于 BaseChannel: true

选型与落地时容易踩的三个坑

  • 在工厂函数里塞进大量方法并高频调用:如果一个工厂函数包含十几个工具方法且会被循环创建几千次,除了考虑改用构造函数,也可以把不依赖实例状态的纯逻辑抽成模块级独立函数,让返回对象只引用这些共享函数。
  • 在构造函数里手动 return 一个新对象字面量:JavaScript 的 new 有个特殊规则——如果构造函数显式返回一个非 null 对象,new 创建出来的 this 实例会被直接丢弃,最终返回你写的新对象。这意味着实例与原型的链接会彻底断掉,instanceof 也会随之失效。
  • 为了用工厂而丢掉类型提示(TypeScript 场景):在 TypeScript 项目里,写 class 可以直接把类名当作类型注解;写工厂函数时,通常需要配合 ReturnType<typeof createOrder> 或提前定义 interface 来保持良好的代码提示。

核心差异总结对照

最后把两种方式在五个核心维度上的行为差异集中整理成对照表和矩阵图,方便你在代码评审或技术选型时快速核对:

评估维度 工厂模式(Factory Function) 构造函数(Constructor / class)
调用方式 普通函数调用,无漏写 new 风险 必须使用 new(ES6 class 漏写直接报错)
方法内存 每次调用默认创建新方法副本,适合少量对象 方法存放在 prototype 上,多实例共享一份
类型识别 默认是 Object,需靠自定义字段或结构判断 原生支持 instanceof、constructor 与继承
私有数据 通过函数闭包天然隔离,外部无法访问 传统靠命名约定,现代 class 可用 # 私有字段
动态与缓存 可根据参数返回不同结构或已有缓存实例 固定生成该类新实例,不宜强改返回值
JS工厂模式与构造函数实例化对象怎么选
图4:JS 工厂模式与构造函数核心差异及组合实践总结矩阵
作者最新文章
相关文章
更多