怎么用JS构造函数和new关键字创建对象

作者:木棉时间:2026-11-21 11:48:44浏览:608

本文以清晰实用的方式,详细讲解如何使用 JavaScript 构造函数与 new 关键字创建对象,剖析 new 的底层执行步骤、实例属性与原型方法的性能差异,并提供遗漏 new 时的安全防御方案。

一、基础实践:定义构造函数并使用 new 实例化

构造函数在语法形式上就是一个普通的 JavaScript 函数。为了让开发者一目了然地区分“普通执行函数”与“对象构造器”,社区约定构造函数采用大驼峰命名法(PascalCase),即首字母大写。

在构造函数内部,开发者不需要手动声明一个空对象,也不需要显式写出 return。通过 this.属性名 = 值 的赋值语句,就可以把调用时传入的参数挂载到将要生成的目标实例上。外部调用时,在函数名前加上 new 运算符即可完成对象的实例化。

// 步骤 1:声明首字母大写的构造函数
function User(name, role) {
  // 步骤 2:通过 this 为新实例初始化属性
  this.name = name;
  this.role = role;
  this.createdAt = new Date();
}

// 步骤 3:使用 new 关键字创建具体实例
const user1 = new User("张三", "管理员");
const user2 = new User("李四", "开发者");

// 验证结果:两个实例拥有各自独立的数据空间
console.log(user1.name); // 输出: "张三"
console.log(user2.name); // 输出: "李四"
console.log(user1 instanceof User); // 输出: true

上述代码中,user1 和 user2 是两个相互独立的内存实体。修改 user1.name 不会对 user2.name 产生任何干扰。这种规范的编写与调用过程可以用下面的三步模型来概括:

怎么用JS构造函数和new关键字创建对象
图 1:构造函数声明与 new 实例化的三个具体操作步骤

二、核心机制:new 关键字在底层完成了什么

表面上看,我们只是在函数前加了一个单词 new,但实际上 JavaScript 引擎在幕后执行了严密的四步操作:

  1. 分配空对象:在堆内存中新分配一个普通的空对象 {}。
  2. 链接原型指针:将这个新对象的隐式原型属性 [[Prototype]](代码中通常可通过 __proto__ 或 Object.getPrototypeOf 访问)指向构造函数的 prototype 原型对象。
  3. 绑定上下文并执行代码:将构造函数内部的 this 绑定到刚刚创建的这个新对象上,并传入实参执行函数体,为新对象添加属性。
  4. 裁决返回值:检查构造函数执行后的返回值。如果函数显式返回了一个非 null 的对象引用,则最终返回该自定义对象;否则无条件返回步骤 1 中创建的新对象。
怎么用JS构造函数和new关键字创建对象
图 2:new 运算符底层的执行时序与返回值裁决逻辑

为了彻底验证上述四步机制,我们可以用一个原生 JavaScript 函数来手动模拟 new 运算符的行为。通过代码的推导,读者可以更直观地看清它的运作细节:

// 模拟原生 new 关键字执行过程的工具函数
function myNew(constructorFn, ...args) {
  // 第 1 步 & 第 2 步:创建新对象,并将其原型连接至构造函数的 prototype
  const obj = Object.create(constructorFn.prototype);

  // 第 3 步:绑定 this 为新对象,并执行构造函数
  const result = constructorFn.apply(obj, args);

  // 第 4 步:判断返回值类型。如果是对象或函数引用则优先返回,否则返回 obj
  const isObject = (typeof result === 'object' && result !== null) || typeof result === 'function';
  return isObject ? result : obj;
}

// 验证测试:使用自定义 myNew 实例化对象
const userTest = myNew(User, "王五", "测试员");
console.log(userTest.name); // 输出: "王五"
console.log(userTest instanceof User); // 输出: true

三、方法挂载对比:实例自身方法 vs 原型共享方法

在创建对象时,初学者常常面临一个关键抉择:方法到底应该写在构造函数里面,还是写在构造函数的 prototype 原型上?

这两种做法在代码语法上都能正常运行,但在内存开销、执行效率和实例一致性上存在本质差异。在一致的调用条件下,我们对比这两种做法的实际表现:

// 做法 A:在构造函数内部通过 this 声明方法(反模式)
function BadUser(name) {
  this.name = name;
  this.sayHello = function() {
    return "你好,我是 " + this.name;
  };
}

// 做法 B:在 prototype 原型对象上挂载公共方法(推荐标准做法)
function GoodUser(name) {
  this.name = name; // 仅挂载独有属性
}
GoodUser.prototype.sayHello = function() {
  return "你好,我是 " + this.name;
};

// 验证关键差异:函数引用的同一性
const b1 = new BadUser("Alice");
const b2 = new BadUser("Bob");
console.log(b1.sayHello === b2.sayHello); // 输出: false!(内存中存在 2 份独立的函数实体)

const g1 = new GoodUser("Alice");
const g2 = new GoodUser("Bob");
console.log(g1.sayHello === g2.sayHello); // 输出: true!(两个实例共享原型上的同一个函数引用)
怎么用JS构造函数和new关键字创建对象
图 3:构造函数内部定义方法与 prototype 原型共享方法的内存结构差异对照

为什么这个差异至关重要?

  • 内存消耗差异:如果把方法写在构造函数内,每次执行 new 都会重新在堆内存中开辟一块空间存放闭包函数对象。如果有 10,000 个实例,就会产生 10,000 个功能一模一样的函数实体。而挂载在 prototype 上时,无论生成多少个实例,该方法在内存中永远只占用一份存储空间。
  • 动态修改与热更新能力:挂载在原型上的方法,后续如果需要修复逻辑或增强功能,只要修改 GoodUser.prototype.sayHello,所有已经创建的实例都会立刻同步感知新行为。而在函数体内定义的方法则彻底固化在每个实例内部,无法统一维护。
架构黄金法则:在 JavaScript 面向对象设计中,“状态属实例,方法归原型”。构造函数负责初始化不同实例独有的数据属性,而通用的行为逻辑一律挂载在 Constructor.prototype 上。

四、常见陷阱与防御:漏写 new 的影响与纠偏技巧

在编写代码时,开发者最容易犯的错误就是直接调用构造函数而忘记书写 new 关键字。例如直接执行 const u = User("小明", "访客");。

1. 漏写 new 的破坏性影响

一旦漏写 new,构造函数就退化成了普通函数调用:

  • 非严格模式下(Non-strict Mode):函数内的 this 默认指向全局对象(浏览器的 window 或 Node.js 的 global)。此时 this.name = name 会把变量意外注册到全局作用域,造成严重的全局变量污染;同时函数没有显式返回值,接收到的变量值为 undefined。
  • 严格模式下(Strict Mode,即 "use strict"):普通函数调用时 this 为 undefined。执行 this.name = ... 会立即抛出类型错误异常:TypeError: Cannot set properties of undefined。

2. 工程级防御:使用 new.target 自动纠正

ES6 引入了专门用于检测函数是否通过 new 调用的元属性 new.target。当通过 new 运算符调用时,new.target 指向该构造函数本身;如果是普通函数调用,new.target 则为 undefined。

我们可以借助 new.target 编写兼具兼容性与容错性的“自适应构造函数”:

function SafeUser(name, role) {
  // 防御检测:如果调用时没有加 new,自动转为 new 调用并返回
  if (!new.target) {
    return new SafeUser(name, role);
  }

  this.name = name;
  this.role = role;
}

// 容错测试:即使漏写 new 也能安全得到正确实例
const userA = SafeUser("赵六", "设计师");
console.log(userA.name); // 正常输出: "赵六"
console.log(userA instanceof SafeUser); // 输出: true
注意 ES6 class 的天然保护:ES6 引入的 class 语法糖底层依然基于上述原型与构造函数机制。但 class 在语言层面进行了硬性约束:如果对 class 不加 new 直接调用,引擎会直接抛出 TypeError: Class constructor cannot be invoked without 'new',从而杜绝此类失误。

五、全景总结

掌握构造函数与 new 关键字的对象创建机制,关键在于理清三个角色的分工协作:

  • 构造函数:作为初始化模板,定义实例自有状态。
  • new 关键字:作为底层自动化调度器,完成开辟内存、绑定 this、建立原型连接并确保实例返回。
  • prototype 原型:作为行为逻辑的共享载体,确保同类实例高复用、低消耗地运行。
怎么用JS构造函数和new关键字创建对象
图 4:JavaScript 构造函数、new 运算符、原型链与防御体系全景知识图谱

在实际项目开发中,牢记“属性在构造函数中绑定、方法在原型链上共享”,并善用 new.target 防御调用疏漏,就能写出结构优雅、性能优异且坚固稳定的 JavaScript 面向对象代码。

作者最新文章
相关文章
更多