JS数组直接赋值为何修改一个会影响另一个?

作者:闭包旅人

时间:2026-11-21

浏览:149

深入解析JavaScript数组直接赋值时修改一个会影响另一个的底层原因,对比基本类型与引用类型的内存模型,详解修改属性与变量重赋值的区别,并给出浅拷贝与深拷贝的完整解决方案与工程实践选型建议。

文章目录
JavaScript 原理与进阶

在 JavaScript 中,将一个数组直接赋值给另一个变量(如 const arr2 = arr1)后,修改 arr2 中的元素会导致 arr1 同步发生变化。产生这一现象的根本原因在于:JavaScript 中的数组属于引用数据类型(Reference Type),变量中存储的并不是数据本身的副本,而是数组在内存堆(Heap)中的地址指针。 直接赋值操作仅仅是复制了一份地址引用,两个变量最终指向了同一块底层数据。本文将从内存机制、操作差异、浅拷贝与深拷贝解决方案等方面,为你系统梳理其底层原因及正确的应对方法。

JS数组直接赋值为何修改一个会影响另一个?
图 0:JavaScript 数组直接赋值在代码表现与底层内存中的映射关系

一、现象复现:看似独立的两个变量

许多初学者在刚接触 JavaScript 时,往往会写出如下代码,并对运行结果感到困惑:

// 声明源数组并直接赋值给新变量
const arr1 = [1, 2, 3];
const arr2 = arr1;

// 仅通过 arr2 修改第一个元素
arr2[0] = 99;

// 查看打印结果
console.log(arr2); // 输出: [99, 2, 3]
console.log(arr1); // 输出: [99, 2, 3] —— arr1 也被连带修改了!

直觉上,我们声明了两个不同的变量名 arr1 与 arr2,理应各自维护一份独立的数据。这种直觉往往来自对基础数据类型(如数字、字符串)的操作经验。例如在处理数字时:

let num1 = 10;
let num2 = num1; // 赋值
num2 = 99;       // 修改 num2

console.log(num1); // 输出: 10(完全不受影响)
console.log(num2); // 输出: 99

同样是 = 赋值操作,为什么在基本类型上互不干扰,换成数组之后就“牵一发而动全身”?要解开这个谜题,必须深入理解 JavaScript 的内存管理模型。

二、底层原理解析:栈内存与堆内存的存储分工

JavaScript 引擎在执行代码时,将内存空间主要划分为两大部分:栈内存(Call Stack)和堆内存(Heap Memory)。不同数据类型的存储位置和访问方式有着本质差异:

  • 栈内存(Stack): 由系统自动分配和释放,内存结构严密连续,存取速度极快。基本数据类型(如 Number、String、Boolean、null、undefined、Symbol、BigInt)的大小固定,它们的值直接保存在栈内存中。
  • 堆内存(Heap): 存储空间大且呈树状或散列分布,用于动态分配大小不固定、结构复杂的对象。引用数据类型(如 Array、Object、Function 等)的实际数据实体都存放在堆内存中。

对于引用类型,变量在栈内存中存储的并非数据实体,而是一个指向堆内存具体地址的指针(Memory Address Reference)。

当你执行 const arr2 = arr1; 时,JavaScript 引擎在栈内存中执行的操作仅仅是:把 arr1 中保存的指针值(例如 0x4A20)原封不动地复制给 arr2。它并没有在堆内存中重新申请空间,更没有把数组内容复制一份。结果就是,arr1 与 arr2 在栈中各自持有了一个指针,但两个指针完全指向堆内存中的同一块地址。

JS数组直接赋值为何修改一个会影响另一个?
图 1:基本数据类型与引用数据类型的内存分配及直接赋值时的指针复制机制
💡 核心关键点: 直接赋值(=)只发生在栈内存中。它只负责复制变量当前格子里存的内容。如果格子里是数值就复制数值;如果格子里是指针就复制指针。赋值本身绝不会自动深入堆内存去克隆实体对象。

三、关键细节辨析:修改内部元素与重新赋值的区别

在讨论变量连带影响时,很多开发者容易把“修改内部属性”与“对变量重新赋值”混为一谈。理解这两者的不同,是写出健壮代码的关键。

1. 修改内部元素(Mutation)

使用索引赋值(如 arr2[0] = 99)或者调用数组的变异方法(如 push()、pop()、splice()、sort())时,变量 arr2 在栈中保存的指针并没有任何变动。代码是通过这个指针,顺藤摸瓜找到了堆内存中的数组实体,并修改了里面的内容。因为 arr1 也指向这个堆实体,所以通过 arr1 读取时,自然看到了被修改后的最新数据。

2. 变量重新赋值(Reassignment)

如果将一个新数组直接赋给变量(如 arr2 = [4, 5, 6],此时 arr2 需用 let 声明),情况就完全不同了。赋值运算符右侧的 [4, 5, 6] 是一个全新的数组字面量,JavaScript 引擎会在堆内存中开辟一块全新的空间(例如地址 0x28B),并将这个新地址写入 arr2 的栈内存中。

此时,arr2 的指针被重定向,它与原数组 arr1 之间的引用关系被彻底切断。后续再对 arr2 做任何增删改,都不会对 arr1 造成丝毫影响。

JS数组直接赋值为何修改一个会影响另一个?
图 2:修改内部项(共享指针)与重新赋值(新建堆内存并重定向指针)的运行路径差异
⚠️ 常见疑问:为什么用 const 声明的数组还能修改元素? const 关键字的作用是保证变量在栈内存中的值不可改变。对于数组而言,栈内存中存储的是堆内存的“指针地址”。只要你没有尝试去改变这个指针(即没有对 arr 进行 = 重新赋值),修改指针指向的堆内存内部内容完全符合 const 的语义规则。

四、解决方案:如何安全复制数组以切断引用关系

如果我们希望得到一个与原数组内容完全相同、但又相互独立的全新数组,就不能直接使用 = 赋值,而必须采用数据拷贝技术。根据数组内部元素的复杂度,复制策略分为浅拷贝(Shallow Copy)和深拷贝(Deep Copy)。

4.1 一维纯基础类型数组:浅拷贝(Shallow Copy)

浅拷贝会创建一个全新的外层数组实体(在堆内存中开辟新空间),并将原数组各索引位置的值逐一复制进去。对于一维且只包含基础类型的数组,浅拷贝即可满足完全解耦的需求。

  • 方法一:扩展运算符(Spread Operator,推荐)
    const arr1 = [1, 2, 3];
    const arr2 = [...arr1]; // 展开元素并装入新数组
    
    arr2[0] = 99;
    console.log(arr1); // 输出: [1, 2, 3] (不受影响)
    console.log(arr2); // 输出: [99, 2, 3]

    这是现代 ES6+ 项目中最常用、语法最为简练的方式。

  • 方法二:Array.prototype.slice() 方法
    const arr2 = arr1.slice(); // 不传参默认提取全部项并返回新数组

    经典的 JavaScript 原生方法,兼容所有浏览器环境。

  • 方法三:Array.from() 静态方法
    const arr2 = Array.from(arr1); // 从类数组或可迭代对象创建新副本
⚠️ 浅拷贝的边界局限: 浅拷贝只能复制数组的“第一层”。如果数组内部包含了对象或子数组(例如 const list = [{ id: 1 }, { id: 2 }]),浅拷贝创建的新数组里,每一项存放的依然是内层对象的指针!此时如果修改 list2[0].id = 888,源数组 list[0].id 依然会随之改变。遇到多维或嵌套数据时,必须使用深拷贝。

4.2 包含嵌套对象或多维数组:深拷贝(Deep Copy)

深拷贝会递归遍历源数组的每一个层级,遇到对象或数组就为其在堆内存中新建空间,实现所有层级数据引用的彻底切断。

  • 现代原生标准方案:structuredClone()

    HTML 规范制定的全局原生 API,已被所有现代主流浏览器(Chrome 98+、Firefox 94+、Safari 15.4+)以及 Node.js 17+ 原生支持:

    const complexArr = [{ name: "Alice" }, [10, 20]];
    const safeCopy = structuredClone(complexArr);
    
    // 修改内层深层属性
    safeCopy[0].name = "Bob";
    safeCopy[1][0] = 999;
    
    console.log(complexArr[0].name); // 依然是 "Alice",完全不受影响!
    console.log(complexArr[1][0]);  // 依然是 10

    structuredClone 相比传统做法不仅性能更好,还原生支持处理循环引用(Circular References),以及 Date、RegExp、Map、Set、ArrayBuffer 等复杂对象。

  • 传统简易方案:JSON 序列化(有损)
    const safeCopy = JSON.parse(JSON.stringify(complexArr));

    通过将数组转为 JSON 字符串再解析回新对象,可以简易切断多层引用。但请谨记其明显缺陷:它会静默丢弃值为 undefined、Function 和 Symbol 的字段,会将 Date 对象转成普通字符串,若存在循环引用还会直接抛出运行时错误。

JS数组直接赋值为何修改一个会影响另一个?
图 3:数组安全复制四步实施路径(从结构评估、方案选型、代码编写到隔离验证)

五、工程实践与方案决策矩阵

在实际前端工程开发中(尤其是使用 React、Vue 等现代视图框架时),推崇不可变数据(Immutability)原则:永远不要直接修改旧的状态数组,而是基于旧数据生成一份新的独立数组并替换更新。这不仅能保证视图响应式侦测的准确性,还能避免隐晦的全局状态污染 Bug。

在进行方案选型时,可参考以下全景决策矩阵,根据运行环境与数据特征选用最恰当的手段:

JS数组直接赋值为何修改一个会影响另一个?
图 4:JavaScript 数组赋值与复制全方案全景决策对比矩阵

六、核心要点总结清单

归纳本文的核心结论,方便在日常编码与代码审查中快速自查:

  1. 根本原因: 数组是引用类型,其数据实体存储在堆内存中。直接赋值 arr2 = arr1 仅复制了栈内存中的堆地址指针,两个变量本质上是在共同引用同一份底层数据。
  2. 行为辨析: 改变内部项(如 arr2[0] = 99、push())不会改变指针,因而相互波及;重新赋值(如 arr2 = [1, 2])会新建堆空间并重写指针,与原数组彻底解耦。
  3. 复制手段: 一维基础类型数组,优先使用 [...arr] 扩展运算符;包含多层嵌套对象的数据结构,优先使用现代原生的 structuredClone(arr)。

实用工具推荐

电子包浆

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

使用 ›
图片压缩

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

使用 ›
相关文章