为什么JavaScript对象传参像引用传递?栈内存与堆内存解析

作者:青柠时间:2026-11-20 11:10:14浏览:601

深入解析JavaScript中对象作为参数传递时的底层机制。通过栈内存与堆内存的物理模型,彻底讲清为什么修改对象属性会影响外部,而重新赋值却互不影响。

JavaScript 底层机制 阅读时长约 8 分钟 主题:内存模型与参数求值
为什么JavaScript对象传参像引用传递?栈内存与堆内存解析
导读图:参数传递时,形参复制了栈内的堆内存指针,二者指向同一堆对象
核心结论先明晰:在 JavaScript 中,所有函数的参数传递都是纯粹的“按值传递”(Pass by Value),语言底层并不存在“按引用传递”(Pass by Reference)机制。之所以在传入对象时“感觉像引用传递”,是因为对象作为引用类型,存储在栈内存中的“值”本身并非对象实体,而是一串指向堆内存的内存地址指针。当对象作为参数传入函数时,系统复制了这串指针值给形参;形参和外部实参各自拥有独立的栈内存槽位,却碰巧指向了堆内存中的同一个对象实体。这种特殊形式在计算机科学中被称为按共享传递(Call by Sharing)。

一、一个让人困惑的代码现象

许多刚接触 JavaScript 的开发者在编写函数时,常常遇到看似自相矛盾的现象。我们先看下面两段简短却极具代表性的代码。

代码一:修改对象属性,外部变量被同步改动

function modifyAge(person) {
  person.age = 30; // 直接修改形参对象的属性
}

const user = { name: "张三", age: 20 };
modifyAge(user);

console.log(user.age);
// 输出结果:30(外部变量的 age 确实被改变了!)

看到这个结果,很多人的第一直觉是:“在函数内部修改 person,外部 user 跟着改变,这不就是经典的按引用传递吗?”然而,如果我们对代码稍作调整,进行完全重新赋值,奇怪的事情就发生了。

代码二:重新为形参赋值,外部变量却毫发无损

function resetPerson(person) {
  person = { name: "李四", age: 18 }; // 直接重新赋予一个新对象
}

const user = { name: "张三", age: 20 };
resetPerson(user);

console.log(user.name);
// 输出结果依然是:"张三"(外部完全没有变成李四!)
思考悖论:如果 JavaScript 对象传参真是“按引用传递”,那么 person = { ... } 应当直接将外部 user 的引用也改写为新对象;如果它是“浅复制或值传递”,那么 person.age = 30 又绝对不应该污染外部对象。要想彻底理顺这一矛盾,必须深入到底层的栈内存与堆内存。

二、底层基石:栈内存与堆内存的存储分工

JavaScript 引擎在执行代码时,需要对数据进行内存分配。受限于运行效率与硬件特性,内存被划分为不同角色的区域,其中最核心的两个区域便是栈内存(Stack)与堆内存(Heap)。

为什么JavaScript对象传参像引用传递?栈内存与堆内存解析
图 1:JavaScript 栈内存(连续高效)与堆内存(动态灵活)物理分工

1. 栈内存(Stack):轻量、连续且高度有序

栈内存由操作系统或 JavaScript 引擎底层的调用栈直接管理,遵循后进先出(LIFO)原则。它的存取速度极快,但空间大小有限,因此只适合存放大小固定、占用空间小的数据:

  • 原始类型值:Number、String(短字符串通常直接优化存储)、Boolean、Null、Undefined、Symbol、BigInt。它们的值直接内嵌存放在栈槽中。
  • 执行上下文环境:当前正在执行的函数调用帧、局部变量环境和参数表。
  • 对象的引用地址:对于复杂对象,栈内存中只存放一个固定长度的指针(如十六进制地址 0x00A1)。

2. 堆内存(Heap):无序、灵活的大容量动态空间

堆内存是一片动态分配的大空间,遵循由申请者动态分配、垃圾回收器(Garbage Collector)异步扫描回收的机制。对象的属性数量可增可减、体积可能非常庞大,因此 JavaScript 会将对象(Object)、数组(Array)以及函数(Function)的实际数据全部安置在堆内存中。

当我们在代码中书写 let user = { name: "张三" } 时,引擎实际上执行了两个动作:

  1. 在堆内存中开辟一块空间,存放键值对数据,并产生一个唯一的物理堆地址(例如 0x00A1);
  2. 在当前作用域的栈内存中为变量 user 分配一个存储单元,并将该地址 0x00A1 写入其中。

三、函数调用时到底传递了什么?执行推导四步法

理解了栈和堆的分工,我们再来看函数调用发生的瞬间。在 ECMAScript 规范中明确规定:所有参数在传入函数时,都是对实参的值进行求值,然后将得到的值赋予形参。

为什么JavaScript对象传参像引用传递?栈内存与堆内存解析
图 2:函数调用时参数按值传递(指针拷贝)的四步执行推导

我们可以将这个调用过程清晰地拆解为四个物理微步骤:

步骤 1:全局作用域初始化

定义外部变量 let player = { hp: 100 };。此时堆内存中开辟了一个包含 hp: 100 的结构体,地址假设为 0x01E8。全局执行栈中的 player 槽位记入 0x01E8。

步骤 2:创建局部执行上下文与新栈帧

当执行 damage(player) 时,JS 引擎在调用栈顶部压入一个新的函数执行栈帧。引擎在此栈帧中为形参 target 分配属于该函数的局部变量存储槽位。

步骤 3:实参“值”的拷贝传递(核心关键)

引擎读取实参 player 栈槽位里的内容。因为 player 是引用类型变量,它栈槽里的“值”就是那串地址 0x01E8。引擎将 0x01E8 这个数值直接复制一份,填写入 target 的栈槽中。请注意:这一步是纯粹的值拷贝!就像将数字 100 复制给另一个变量一样,并没有把变量 player 本身绑定给 target。

步骤 4:共同寻址同一个堆对象

此时,全局的 player 和局部的 target 存在于两个完全独立的栈槽位中,但它们内部填写的十六进制堆地址都是 0x01E8。因此,两者在逻辑上都指向了堆内存中的同一个对象实体。这就是为什么学术界将这种行为特称为按共享传递(Call by Sharing)。

四、微观演化对比:“修改属性”与“重新赋值”

至此,文章开头提出的两段代码行为差异已经呼之欲出。让我们通过微观内存变化图,将这两种操作进行同台对比。

为什么JavaScript对象传参像引用传递?栈内存与堆内存解析
图 3:微观演化对比——修改对象属性 vs 重新赋值形参

场景 A:修改对象属性(target.hp = 80)

当执行 target.hp = 80 时:

  1. 引擎首先读取形参 target 栈槽中的内容,拿到地址 0x01E8;
  2. 通过地址 0x01E8 寻址到堆内存中的实体对象;
  3. 在堆内存中找到属性 hp,将其值由 100 改写为 80;
  4. 操作完成,此时形参 target 和外部 player 的栈槽位内容没有任何变化,但它们共同指向的堆内存数据被直接修改了。

当函数执行完毕退出、局部栈帧被销毁后,外部代码再去访问 player.hp,依旧是循着 0x01E8 寻址堆内存,自然读取到了改动后的 80。这便产生了“外部对象被修改了”的表象。

场景 B:重新赋值形参(target = { hp: 50 })

当执行 target = { hp: 50 } 时,情况截然不同:

  1. 右侧的对象字面量 { hp: 50 } 触发了新的内存分配。引擎在堆内存中开辟了一块全新的独立空间,其地址为 0x02F4;
  2. 赋值操作符 = 针对的是变量 target 本身,因此引擎将新地址 0x02F4 写入 target 自己的栈槽中;
  3. 原先指向 0x01E8 的旧关联被单方面切断,target 从此与原对象再无瓜葛;
  4. 外部变量 player 处于外部栈帧中,它的栈槽依旧完好保存着 0x01E8,原堆对象也依然是 { hp: 100 }。

这个事实无可辩驳地证明了:JavaScript 绝不是按引用传递。如果在支持真正按引用传递的语言(如 C++ 的 void fn(int& ref))中,对形参重新绑定将直接重定向调用方的实参变量,而这在 JavaScript 中是根本无法做到的。

五、工程实践与避免副作用

理解了按共享传递的底层机理后,我们在日常工程开发中就能建立起极强的边界感,避免写出暗藏隐患的代码。

1. 警惕隐蔽的“参数突变”(Mutation)副作用

在团队协作中,如果一个函数内部随意修改传入对象的属性,调用方在不知情的情况下继续使用该对象,就会产生极难排查的状态同步 Bug。这种在函数内部悄悄篡改入参属性的行为被称为突变(Mutation)。

// 危险的做法:产生不可预料的外部副作用
function applyDiscount(cart) {
  cart.total = cart.total * 0.8; // 悄悄修改了外部 cart
  return cart;
}

// 安全的做法:纯函数(Pure Function),拷贝后返回新对象
function applyDiscountSafe(cart) {
  return {
    ...cart,
    total: cart.total * 0.8 // 不触碰原对象,构建新堆对象返回
  };
}

2. 防御性拷贝策略:浅拷贝与深拷贝

拷贝方式 典型实现手段 堆栈变化原理 适用场景与局限
浅拷贝 (Shallow Copy) { ...obj }
Object.assign({}, obj)
在堆中开辟新对象,但如果属性值仍是对象,则复制其堆指针。 对象只有单层简单属性时安全;嵌套对象属性仍会共享堆内存。
深拷贝 (Deep Copy) structuredClone(obj)
JSON.parse(JSON.stringify(obj))
递归为所有层级的对象在堆中开辟新空间,彻底切断所有指针共享。 完全隔离外部引用;但大对象耗费更多堆内存与递归时间。

六、全景总结:参数传递决策模型

为了让读者在面对任何代码时都能迅速做出准确判断,我们用一张决策流程图总结参数传递与内存行为的全部推导链路:

为什么JavaScript对象传参像引用传递?栈内存与堆内存解析
图 4:JavaScript 参数传递与内存行为总结决策图

三个永远适用的核心法则

  1. 传递规则唯一:JavaScript 中无论是基本类型还是对象类型,参数传递只有按值传递一种规则。
  2. 所谓“引用”只是数值:对于对象而言,栈内存中保存的值是一串“堆地址数据”。传参时复制的就是这串地址数据自身,绝非对象本体,更不是实参变量本身。
  3. 操作行为定结果:对形参的属性进行“点操作(.)”或“方括号操作([])”,是通过指针在访问和修改堆内存;而直接对形参使用赋值号(=),是在改写形参自己栈内存里的地址指针,两者有着截然不同的物理意义。
作者最新文章
相关文章
更多