JS new关键字底层原理:实例化对象时发生了什么

作者:闭包旅人

时间:2026-11-21

浏览:589

深入剖析 JavaScript 中 new 关键字实例化对象时的底层执行流程,解析 ECMAScript 规范中的四个原子操作:内存分配、原型链链接、this 上下文绑定及返回值裁决,并提供完整手写实现与边界陷阱防范。

文章目录

一、从一个简单示例看 new 的表象行为

很多初学者接触面向对象时,习惯直接写出类似下面的代码:

function User(name, role) {
  this.name = name;
  this.role = role;
}

User.prototype.greet = function() {
  return `你好,我是 ${this.name}`;
};

const user1 = new User('张三', '工程师');
console.log(user1.name); // 打印: "张三"
console.log(user1.greet()); // 打印: "你好,我是 张三"

表面上看,User 只是一个普通函数,但前面加上 new 之后,它却产出了一个具备独立属性(name、role)、同时可以调用原型方法(greet)的对象。如果省略 new 直接调用 User('张三', '工程师'),不仅无法获得实例,还会将属性挂载到全局作用域。

这一巨大差异的根本原因,在于 new 触发了 JavaScript 引擎底层的对象构造机制。下面我们逐层拆解这套机制的完整运作链条。

二、实例化四部曲:底层推导与执行链条

根据 ECMAScript 规范对内部方法 [[Construct]] 的定义,当引擎解析到形如 new F(args) 的表达式时,会在内部启动如下四个连续步骤:

JS new关键字底层原理:实例化对象时发生了什么
图 1:JavaScript 引擎执行 new 操作符时的四步原子推导流程

第一步:在堆内存中创建新对象

JS 引擎会在堆内存(Heap)中分配一段全新的空间,生成一个没有任何自身特有属性的纯净普通对象(类似于 {})。这一步确保了每一个通过 new 产生的实例在内存地址上都是完全独立的,互不污染。

第二步:链接原型对象(继承机制的确立)

新创建的对象必须能够访问构造函数上定义的共享资源。引擎会获取构造函数的 prototype 属性,并将新对象的内部槽 [[Prototype]](在浏览器中常暴露为 __proto__)指向该原型对象。等价于执行:

Object.setPrototypeOf(newObject, Constructor.prototype);

正是这一步,确立了 JavaScript 中对象与构造函数之间的原型链关系。所有写在 Constructor.prototype 上的方法,在新对象上都可以直接通过属性查找机制获取。

第三步:绑定 this 并执行构造函数体

接下来,引擎调用构造函数代码,但关键在于执行上下文的重定向:将构造函数执行期内的 this 强制绑定为第一步创建的 newObject,并将传入的参数列表依次注入:

Constructor.apply(newObject, args);

在函数体内,凡是形如 this.name = name 的语句,实际上都是在直接修改 newObject 的自身属性。

第四步:检查返回值类型并做出仲裁

构造函数执行完毕后,引擎会捕获该函数的实际返回值。这里存在一个非常容易被忽略的语言设计细节:构造函数并不总是返回第一步创建的新对象。

  • 如果构造函数显式返回了一个引用类型对象(如普通对象 {}、数组 []、函数等),则 new 表达式的求值结果为该返回对象,第一步创建的 newObject 被弃用。
  • 如果构造函数没有显式返回值(默认返回 undefined),或者显式返回了一个原始类型数据(如 123、"hello"、true、null),引擎会直接忽略这个原始返回值,将第一步创建并初始化的 newObject 交付给调用方。

三、原型链架构:prototype 与 [[Prototype]] 的协同

很多人容易将函数的 prototype 和对象的 __proto__ 混为一谈。理解 new 的运作,必须透彻掌握二者在内存中的分工与空间映射:

JS new关键字底层原理:实例化对象时发生了什么
图 2:构造函数、原型对象与多个实例对象的内存布局拓扑

从架构图可以清晰看出:

  1. 构造函数拥有显式原型 prototype:当一个函数被声明时,JS 会自动为它创建一个原型对象,用于存放所有实例共享的属性与方法。
  2. 实例对象拥有隐式原型 [[Prototype]]:实例本身并不复制 sayHello 方法的代码,它仅仅保存了一个指向 Person.prototype 的指针。
  3. 内存节约与原型回溯:当同时实例化 p1 与 p2 时,实例各自持有自己的 name 字段,而调用 p1.sayHello() 时,由于 p1 自身没有该函数,引擎便沿着 __proto__ 向上检索,最终在 Person.prototype 上成功调用。

四、返回值异常判定:return 基础类型为何被忽略?

在日常开发中,很少有人在构造函数里写 return,但在理解底层原理和排查疑难 Bug 时,这一规则至关重要。

JS new关键字底层原理:实例化对象时发生了什么
图 3:构造函数返回值判定分支树与覆盖逻辑

我们通过两段对比代码来观察其实际表现:

场景一:返回原始类型(被无视)

function Animal(type) {
  this.type = type;
  return '字符串将被忽略'; // 返回原始类型
}

const a = new Animal('Cat');
console.log(a); // 结果: Animal { type: 'Cat' }
console.log(a.type); // 结果: 'Cat'

即使显式写了 return '字符串',通过 new 调用后得到的依然是初始化的 this 实例。返回 null、0、false 也是同样的结果。

场景二:返回引用对象(发生覆盖)

function Widget() {
  this.id = 100;
  return { custom: '覆盖默认对象' }; // 返回独立对象
}

const w = new Widget();
console.log(w.id); // 结果: undefined
console.log(w.custom); // 结果: '覆盖默认对象'
console.log(w instanceof Widget); // 结果: false!
踩坑提醒

一旦构造函数返回了另一个引用类型对象,最初建立的原型链链接就会被完全切断。新得到的变量 w 将不再是 Widget 的实例,也无法调用 Widget.prototype 上的任何方法。

五、动手实现一个符合规范的 myNew 函数

为了检验对这套底层原理的掌握程度,最有效的方法就是脱离语言内建的 new 关键字,纯手写实现一个同等功能的 myNew 辅助函数。

/**
 * 模拟原生 new 操作符
 * @param {Function} Constructor 目标构造函数
 * @param {...any} args 构造函数初始化参数
 * @returns {Object} 实例化对象
 */
function myNew(Constructor, ...args) {
  // 1. 合法性检查:确保传入的是可构造函数
  if (typeof Constructor !== 'function') {
    throw new TypeError('Constructor must be a function');
  }

  // 2. 创建新空对象,并将该对象的 [[Prototype]] 关联至构造函数的 prototype
  // Object.create 底层等同于:const obj = {}; Object.setPrototypeOf(obj, Constructor.prototype);
  const instance = Object.create(Constructor.prototype);

  // 3. 将 instance 绑定为 this 执行构造函数,并传入参数
  const result = Constructor.apply(instance, args);

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

测试与验证

我们用前面的 User 构造函数对 myNew 进行测试:

const u2 = myNew(User, '李四', '架构师');

console.log(u2.name); // 示例输出: '李四'
console.log(u2.greet()); // 示例输出: '你好,我是 李四'
console.log(u2 instanceof User); // 示例输出: true
console.log(Object.getPrototypeOf(u2) === User.prototype); // 示例输出: true

测试结果与原生 new 运算符的表现完全一致,这证明我们的四步逻辑完整覆盖了 ECMAScript 标准规定的一切核心行为。

六、进阶边界与避坑指南

在日常生产代码中,围绕 new 还有以下三个常见的边界条件和安全实践需要掌握:

1. 为什么箭头函数不能使用 new?

如果尝试 new (() => {}),控制台会明确抛出异常:TypeError: ... is not a constructor。原因有两个:

  • 箭头函数在规范中没有内部的 [[Construct]] 方法,只有 [[Call]] 方法。
  • 箭头函数没有 prototype 属性,也无法通过 this 绑定新创建的上下文。

2. 忘记写 new 的危害与解决办法

在 ES6 Class 出现之前,构造函数就是普通函数。如果调用者不小心遗漏了 new,函数就会作为普通函数执行:

  • 在非严格模式下,函数内的 this 会默认指向全局对象(浏览器中的 window,Node.js 中的 global),导致全局命名空间被意外污染。
  • 在严格模式('use strict')下,未绑定的 this 为 undefined,访问 this.name 会立即抛出 TypeError: Cannot set property 'name' of undefined。

3. 使用 new.target 进行防御性编程

ES6 引入了专门的元属性 new.target。当函数通过 new 触发时,new.target 指向该构造函数本身;如果是普通调用,new.target 则为 undefined。我们可以利用这个特性编写自适应构造函数:

function SafeUser(name) {
  if (!new.target) {
    // 如果调用方忘了写 new,内部主动帮其 new 一份
    return new SafeUser(name);
  }
  this.name = name;
}

const a1 = SafeUser('王五'); // 未写 new,依然安全返回正确实例
console.log(a1 instanceof SafeUser); // 示例输出: true

七、机制全景总结

理解 new 关键字不仅能帮助我们写出结构更清晰的代码,更是深入掌握 JavaScript 原型链、面向对象以及执行上下文绑定机制的必经之路。

JS new关键字底层原理:实例化对象时发生了什么
图 4:new 运算符底层机制与实现要点矩阵
环节 原生 new 内部行为 手写模拟关键代码 核心目的与考点
1. 分配空间 在堆内存分配全新基础对象 Object.create() 或 {} 确保实例间内存隔离
2. 继承关系 obj.[[Prototype]] = F.prototype Object.setPrototypeOf() 建立原型链,共享方法
3. 上下文绑定 执行 F.[[Call]](obj, args) F.apply(obj, args) 为新实例挂载私有数据属性
4. 结果仲裁 对象覆盖 vs 原生保留 isObject ? result : obj 防止意外覆盖与工厂模式兼容
要点速记

记住核心四步:一开空对象、二连原型链、三绑 this 执行、四辨返回对象。只要牢牢把握这四个关键节点,无论是在日常开发、代码调试还是技术面试中,涉及 new 的所有变体与考点都能迎刃而解。

实用工具推荐

电子包浆

绿化、压缩、噪点和虚拟水印,自由调节做旧程度。

使用 ›
图片压缩

选择画质和输出格式,预览压缩前后的大小。

使用 ›
相关文章