深入理解 30-seconds-of-interviews 中的 Mutable vs Immutable:JavaScript 可变与不可变值的本质与实战

原创2026-09-22 17:04:581,722 阅读
文章标签:教程前端

深入理解 30-seconds-of-interviews 中的 Mutable vs Immutable:JavaScript 可变与不可变值的本质与实战

导读

本文基于 30-seconds-of-interviews 仓库中的经典面试题 mutable-vs-immutable.md,系统讲解 JavaScript 中"可变(Mutable)"与"不可变(Immutable)"值的核心差异。你将掌握对象与原始值在内存引用层面的根本区别、String.prototype 与 Array.prototype 方法族中哪些会原地修改数据、哪些会返回全新副本,并了解不可变思想在纯函数与函数式编程中的应用。文章还结合仓库源码给出可验证的实现依据,帮助你既答好面试题,又写出更可预测、更易维护的代码。

一、核心概念:Mutable 与 Immutable 的定义

原文档开宗明义给出两个术语的对照:

  • Mutable(可变):subject to change,即"可以改变"。
  • Immutable(不可变):cannot change,即"不可以改变"。

这两个词描述的是数据值本身能否在创建后被修改。在 JavaScript 中,这一区分几乎是所有数据操作错误的根源,也是面试官考察候选人对语言内存模型理解深度的经典切入点。

需要特别强调的是,这里的"不可变"指的是值本身不可改变,而不是"变量"不可重新赋值。一个用 const 声明的对象变量虽然不能重新指向其他对象,但对象内部的属性依然可以被修改——这正是"可变对象"的含义。相关概念还可以参考仓库中 var-let-const.md 对声明方式的讨论。

二、JavaScript 中的分水岭:对象可变,原始值不可变

原文档明确指出 JavaScript 中的关键规律:

In JavaScript, objects are mutable while primitive values are immutable.

翻译并展开就是:对象是可变的,而原始值(primitive values)是不可变的。这意味着:

  • 对对象执行的操作,可能在某种程度上改变原始引用所指的内容;
  • 对原始值执行的操作,永远不可能改变原始值本身。

JavaScript 的原始值包括:string、number、boolean、null、undefined、symbol 以及 bigint。当你对字符串做任何"修改"操作时,得到的都是一个新的字符串,原始字符串从未被改动。

const myString = "hello!"
myString.replace("!", "") // 返回一个新字符串 "hello",原始值无法被改变
console.log(myString)     // 仍然是 "hello!"

对象的可变性则体现在引用共享上。这与仓库中另一道题 pass-by-value-reference.md 的结论一脉相承:JavaScript 总是按值传递,但对于对象,这个"值"是一个指向对象的引用。于是,多个变量可以持有同一份引用,通过任何一个变量修改对象,其他变量观察到的都是被修改后的同一对象。

const originalArray = [1, 2, 3]
const alias = originalArray
originalArray.push(4)     // 原地修改 originalArray,现在是 [1, 2, 3, 4]
console.log(alias)        // alias 也变成 [1, 2, 3, 4],因为二者共享同一引用

对象可变、原始值不可变,直接派生出两个重要推论,分别对应仓库中的另外两题:

  1. 克隆对象时默认是浅克隆:对象展开运算符 ... 和 Object.assign() 只复制第一层属性,嵌套对象仍然共享引用。详见 clone-object.md。
  2. 比较对象时 == / === 比较的是引用而非结构:两个属性完全相同的对象,只要不是同一个引用就不相等。详见 comparing-objects.md。

从源码佐证:为什么"值传递 + 引用共享"如此重要

在 comparing-objects.md 中,仓库提供了一个深度相等判断函数,其开头正是对引用相等的短路判断:

function isDeepEqual(obj1, obj2, testPrototypes = false) {
  if (obj1 === obj2) {
    return true
  }
  // ...
}

这段代码清楚地表明:只有当两个对象是同一个引用时,=== 才直接判定相等;否则必须递归遍历属性逐一比较。这正是"对象按引用比较"这一不可变/可变话题的直接工程体现。该函数还处理了 Date(用 getTime() 比较时间戳)、Function(用 toString() 比较源码)等特殊对象,说明在引用比较之外,深比较仍需针对不同类型逐一处理。

三、字符串方法:一律不可变

原文档指出:

All String.prototype methods do not have an effect on the original string and return a new string.

即 String.prototype 的所有方法都不会影响原始字符串,而是返回一个新字符串。这是因为字符串是原始值,本身就不可能被原地修改。常见方法包括:

方法 作用 是否修改原字符串
replace() 替换匹配的子串 否,返回新字符串
slice() / substring() 截取子串 否
toUpperCase() / toLowerCase() 大小写转换 否
trim() 去除首尾空白 否
concat() 拼接字符串 否
split() / join() 拆分与合并 否
padStart() / padEnd() 填充字符串 否

原文档中的示例:

const myString = "hello!"
myString.replace("!", "") // 返回新字符串,无法改变原始值

运行后 myString 依然是 "hello!",replace 的返回值 "hello" 必须显式赋值给新变量才能被使用。这一行为是"原始值不可变"的最直观体现。

四、数组方法:可变与不可变并存(重点清单)

与字符串的"全都不变"不同,Array.prototype 的方法呈现分裂状态:部分方法会原地修改原数组(mutating),部分方法返回全新数组(non-mutating)。原文档用一段示例展示了这种差异:

const originalArray = [1, 2, 3]
originalArray.push(4) // 原地修改 originalArray,现在为 [1, 2, 3, 4]
originalArray.concat(4) // 返回新数组,不修改原数组

会修改原数组的方法(Mutating)

以下方法会原地修改调用它们的数组,是造成"意外副作用"的头号来源:

  • push():在末尾追加一个或多个元素(上面的例子即此方法);
  • pop():移除并返回末尾元素;
  • shift():移除并返回首部元素;
  • unshift():在首部插入一个或多个元素;
  • splice():在任意位置增删元素;
  • sort():原地排序;
  • reverse():原地反转;
  • fill():用指定值填充;
  • copyWithin():在数组内部复制一段到另一位置。

返回新数组的方法(Non-mutating)

以下方法不会修改原数组,而是基于原数组生成一个新数组:

  • concat():拼接并返回新数组;
  • slice():截取片段返回新数组;
  • map():对每个元素映射后返回新数组;
  • filter():筛选后返回新数组;
  • reduce() / reduceRight():归约(返回归约结果,通常为单值);
  • flat() / flatMap():展平数组;
  • join():返回字符串;
  • indexOf() / includes() / find() 等:查询类方法,返回索引、布尔值或元素,不修改原数组。

与纯函数的结合:map() vs forEach()

仓库中 for-each-map.md 从另一个角度印证了上述区分:

map() maps each element to a new element ... returning a new array. On the other hand, forEach() invokes the callback function for each element but does not return a new array.

  • map() 保持数据不可变:原数组的每个值被映射到一个全新的数组,适合函数式编程风格;
  • forEach() 通常用于产生副作用(side effect),例如在迭代中对元素进行修改,因此不返回新数组。

这直接呼应了本篇文章的"Good to hear"要点:如果需要遍历数组并修改元素,用 forEach() 配合原地操作;如果需要保持数据不可变,则优先 map()。

五、可变性的反面教材与最佳实践:排序与推入

两个看似无害的操作,最容易暴露"可变"的陷阱:

1. sort() 原地排序的坑

const arr = [3, 1, 2]
const sorted = arr.sort((a, b) => a - b)
console.log(arr)    // [1, 2, 3] —— 原数组被改了!
console.log(sorted) // [1, 2, 3] —— 而且和原数组是同一个引用

sort() 是原地操作,想要不污染原数组,需要先复制再排序:

const arr = [3, 1, 2]
const sorted = [...arr].sort((a, b) => a - b) // 先浅拷贝,再排序
console.log(arr)    // [3, 1, 2] —— 原数组保持不动
console.log(sorted) // [1, 2, 3]

2. push() 原地修改的坑

如原文档示例所示,push() 直接改变原数组。若想得到"追加后的新数组"而不动原数组,应改用不可变方式:

const originalArray = [1, 2, 3]
const newArray = originalArray.concat(4) // 返回 [1, 2, 3, 4]
// 或使用展开运算符:
const newArray2 = [...originalArray, 4]
console.log(originalArray) // 仍是 [1, 2, 3]

这一组对比正是本仓库 pure-functions.md 中"纯函数 vs 非纯函数"示例的由来:

// 纯函数(不可变风格)
const b = (arr, value) => arr.concat(value)
const c = arr => [...arr].sort((a, b) => a - b)

// 非纯函数(可变风格)
const b = (arr, value) => (arr.push(value), arr)
const c = arr => arr.sort((a, b) => a - b)

同一逻辑的两种写法,前者返回新数组、不产生副作用;后者原地修改传入的数组,属于典型的外部副作用。面试中如果能主动点出这一对比,会是非常亮眼的加分项。

六、为什么不可变如此重要:纯函数与函数式编程

不可变性不是理论洁癖,而是工程上的可靠性保证。仓库中两道题共同支撑了这一观点:

  • pure-functions.md:纯函数满足两个条件——相同输入必然返回相同输出;不产生函数作用域之外的副作用(即不修改外部数据或传入的数据)。不可变数据正是纯函数"无副作用"的前提。
  • functional-programming.md:函数式编程范式强调用避免共享状态和可变数据的纯函数,以声明式方式构建程序。JavaScript 的 .map、.reduce 等不修改原数组的方法,正是让函数式风格得以成立的基石。

实践中的收益:

  1. 更易推理:函数不偷偷改数据,输出只依赖输入,调试成本显著下降;
  2. 更安全地共享:多个组件/模块共享同一份数据时,不必担心一方修改影响另一方;
  3. 时间旅行与撤销:每次变更都产生新状态而非覆盖旧状态,天然支持历史回退(这也是 React 等 UI 框架偏爱不可变数据的原因之一)。

需要注意的是,不可变并非银弹:深拷贝可能带来 CPU 与内存开销。例如 clone-object.md 指出 JSON.parse(JSON.stringify(obj)) 虽然可以深克隆简单对象,但"CPU-intensive"(CPU 密集)且只接受合法 JSON(会剥离函数、不允许循环引用)。因此在性能敏感场景,应权衡"复制成本"与"共享风险",必要时采用结构共享(如持久化数据结构)等折中方案。

七、如何在面试中组织回答(答题框架)

综合原文档与上述展开,推荐按以下层次组织面试回答:

  1. 给出定义:Mutable 是可改变,Immutable 是不可改变。
  2. 点明 JavaScript 规律:对象可变、原始值不可变;操作对象可能影响原引用,操作原始值不会。
  3. 给出证据:String.prototype 全部方法返回新字符串;Array.prototype 中 push、sort、splice 等原地修改,concat、map、filter 等返回新数组。
  4. 上升到工程实践:不可变数据是纯函数与函数式编程的基石,能降低副作用、提升可预测性;同时指出深拷贝的开销等权衡。
  5. (进阶)关联相关知识:按值传递与引用共享(pass-by-value-reference.md)、浅克隆与深克隆(clone-object.md)、引用比较 vs 结构比较(comparing-objects.md)。

八、延伸阅读:仓库中的相关知识脉络

本仓库 30-seconds-of-interviews 将所有面试题按 Markdown 文件组织在 questions/ 目录,并提供了 question-template.md 作为题目标准格式。每道题遵循 ### 问题 / #### Answer / #### Good to hear / ##### Additional links 的固定结构,并通过 scripts/extract.js 与 scripts/util.js 解析为 data/questions.json,最终由 website/ 前端渲染展示。如果想批量检索"不可变"相关题目,可以直接在 questions/ 目录中搜索 mutable、immutable、pure 等关键词。

与本文主题直接相关的姊妹题包括:

结语

Mutable 与 Immutable 的区分是 JavaScript 数据模型的基石,也是面试高频考点。掌握"原始值不可变、对象可变、数组方法分裂"这三条主线,并理解其在纯函数、函数式编程与克隆/比较中的延伸,你就既能给出准确的定义,又能展示出超越答案本身的工程思维。记住原文档留给读者的那份"Good to hear"清单:熟悉可变与不可变数组方法的完整清单——这正是区分"背答案"与"真理解"的关键一步。

登录后查看全文
30-seconds-of-interviews