JavaScript 中的数组方法数量众多，但 pop() 属于使用频率极高、行为又容易被低估的一个。它负责从数组末尾移除一个元素，并把这个元素作为返回值交给你。与 slice()、concat() 这类返回新数组的方法不同，pop() 会直接改变调用它的数组。这种原地修改的特性，再叠加数组作为引用类型在变量间共享的机制，往往会在不经意间引发数据联动问题。下面从方法机制、引用类型影响和实际开发策略三个层面逐步拆解。
pop() 的基本工作机制与边界行为
从语法上看，pop() 不需要任何参数，它总是作用于数组的最后一个元素。执行过程可以拆成三步：读取当前数组的长度，取出最后一个索引对应的值，然后把数组长度减一。返回的就是被移除的元素。如果数组为空，长度为零，pop() 不会报错，而是返回 undefined，同时数组仍然保持为空。这个边界行为在编写通用逻辑时非常重要，许多开发者会忽略空数组的情况，直接对返回值做属性访问或运算，结果得到 TypeError 或 NaN。
看一段最基础的示例：
const fruits = ['apple', 'banana', 'cherry']; const removed = fruits.pop(); console.log(removed); // 'cherry' console.log(fruits); // ['apple', 'banana'] console.log(fruits.length); // 2
这段代码清晰地展示了 pop() 的两个直接效果：返回被移除的项，同时原数组被修改。与 push() 配合使用时，pop() 可以让数组表现出栈结构的行为——后进先出。对一个空数组调用 pop() 时，返回值是 undefined，这属于正常行为而非异常。因此如果业务逻辑要求移除元素后必须得到一个有效值，应当在调用前先判断数组长度，或者对返回值进行类型检查。
另外需要注意的是，pop() 只操作数组末尾，不涉及中间元素的位移。这一点与 shift() 形成鲜明对比：shift() 移除数组的第一个元素后，所有后续元素都需要向前移动一位，时间复杂度为 O(n)。而 pop() 只缩短长度，时间复杂度为 O(1)。在处理大规模数组或高频操作时，选择 pop() 而非 shift() 可以显著减少计算开销。这也是很多队列和栈实现中，优先使用 push/pop 组合的原因之一。
引用类型特性如何引发联动修改
在 JavaScript 中，数组属于引用类型。变量保存的不是数组本身，而是指向堆内存中数组对象的引用。当把一个数组赋值给另一个变量时，两个变量指向的是同一个数组，而不是复制一份新的数据。这一机制对 pop() 的影响非常直接：通过任意一个引用调用 pop()，都会修改同一个底层数组，其他引用看到的数组内容也会同步变化。
看下面的例子：
const original = [1, 2, 3, 4]; const alias = original; const poppedValue = alias.pop(); console.log(poppedValue); // 4 console.log(alias); // [1, 2, 3] console.log(original); // [1, 2, 3] —— original 也被修改了
这里 original 和 alias 指向同一块数组数据。alias.pop() 执行后，original 的内容也少了一个元素。如果开发者以为 alias 是 original 的副本，就会产生预期之外的副作用。这种联动修改在函数参数传递中同样存在：把数组作为参数传给函数，函数内部调用 pop() 会直接修改外部数组。很多函数式编程风格强调不可变性，就是不希望函数悄悄改变外部状态。
要避免这种意外，需要明确区分赋值与复制。浅拷贝可以打破直接引用关系，例如使用 slice()、展开运算符或 Array.from()。这些方法都会创建一个新数组，新数组中的基本类型元素是独立的。但如果数组元素本身是对象或数组，浅拷贝仍然只复制引用，深层次的数据联动问题依然存在。针对这类嵌套结构，需要借助深拷贝或结构化克隆来彻底隔离。
以下是对比代码：
const source = [{ id: 1 }, { id: 2 }];
// 浅拷贝：外层数组独立，内层对象仍共享引用
const shallow = [...source];
shallow.pop();
console.log(source.length); // 2 —— 外层数组不受影响
// 深拷贝：内层对象也独立
const deep = JSON.parse(JSON.stringify(source));
deep[0].id = 999;
console.log(source[0].id); // 1 —— 源数据不变
在实际开发中，如果只是移除数组末尾的基本类型元素，使用 slice() 或展开运算符生成副本再调用 pop()，就可以保护原始数组。例如 const newArr = [...oldArr]; newArr.pop();。这种方式在 React 状态更新中尤为常见，因为不可变更新能够帮助框架更高效地进行差异比较。
遍历数组时调用 pop() 的陷阱与替代方案
很多开发者在遍历数组的同时尝试删除元素，结果常常出现漏处理或索引错乱。使用 pop() 从末尾删除看似安全，因为不会影响前面元素的索引，但如果使用正向 for 循环并依赖数组长度，仍然会踩坑。例如在执行 for (let i = 0; i < arr.length; i++) 的过程中调用 pop()，每次循环后长度都会变化，导致循环条件动态改变，最终只处理了原本数组的一半元素。
看下面这个容易出错的例子：
const numbers = [1, 2, 3, 4, 5, 6];
for (let i = 0; i < numbers.length; i++) {
if (numbers[i] % 2 === 0) {
numbers.pop();
}
}
console.log(numbers); // 可能不是预期的结果
这段代码的意图是遇到偶数就删除数组末尾的元素，但循环条件中的 numbers.length 会随着 pop() 的执行不断减小，i 却持续增加，导致循环提前结束。正确的做法是反向遍历：从数组末尾开始向前循环，这样删除末尾元素不会影响尚未检查的索引。或者使用 while 循环配合 pop()，每次都从末尾取元素判断，逻辑更清晰。
以下是一种安全的处理方式：
const numbers = [1, 2, 3, 4, 5, 6];
while (numbers.length > 0) {
const item = numbers.pop();
if (item % 2 === 0) {
console.log(item); // 处理偶数
}
}
console.log(numbers); // []
这种 while + pop() 的模式非常适合需要从末尾逐个消费数组的场景，例如任务队列的逆序处理。由于 pop() 是 O(1) 操作，整体复杂度为 O(n)，而且不会产生索引错乱。相比之下，正向遍历加 splice() 或 delete 会面临更多索引管理问题。因此当需要边遍历边删除时，优先考虑从后往前处理。
手写 pop() 理解内部实现与不可变替代方案
深入理解一个方法的最好方式之一就是自己实现它。pop() 的内部逻辑并不复杂：读取数组长度，保存最后一个元素，然后将长度减一，最后返回保存的元素。但要注意，直接修改 length 属性虽然可以截断数组，却无法返回被截断的部分。手写实现时需要显式取出元素。
function customPop(arr) {
if (arr.length === 0) {
return undefined;
}
const lastIndex = arr.length - 1;
const lastValue = arr[lastIndex];
arr.length = lastIndex;
return lastValue;
}
const arr = [10, 20, 30];
console.log(customPop(arr)); // 30
console.log(arr); // [10, 20]
这个简易实现展示了 length 属性在底层的作用。数组的 length 不是只读的，缩短 length 会删除超出部分的元素。原生 pop() 本质上就是类似的逻辑，只不过在 JavaScript 引擎中经过高度优化。理解这一点有助于明白为什么 pop() 只能删除末尾元素——因为它依赖 length 的减少，而数组中间的元素无法通过 length 简单移除。
如果你不希望修改原数组，可以使用 slice(0, -1) 来获得一个去掉末尾元素的新数组。slice 方法支持负索引，-1 表示从末尾截断一个元素。例如 const trimmed = arr.slice(0, -1); 会返回原数组去掉最后一项的副本，原数组保持不变。这种方式适合函数式编程或需要保留历史数据的场景。与 pop() 相比，slice 会创建新数组，内存开销稍高，但换来的是数据不可变性，在多组件共享状态时更安全。
另一个思路是使用展开运算符配合 slice，比如 [...arr].pop()，但这样 pop() 的返回值是元素，而新数组已经丢失了返回元素，需要额外变量保存。更推荐的做法是 const last = arr[arr.length - 1]; const rest = arr.slice(0, -1); 这样同时获取最后一个元素和剩余数组，且不修改原数组。这些替代方案表明，pop() 的原地修改行为并非不可替代，而是需要根据具体场景权衡性能与数据安全。
实际开发中的引用类型隔离策略
在状态管理、组件通信或数据缓存等场景中，数组经常被多个模块共享。直接对共享数组调用 pop() 会造成隐式耦合，让数据变化变得难以追踪。为了降低风险，可以遵循一条简单原则：除非明确需要原地修改，否则先复制数组再操作。复制数组的常见方式包括 slice()、展开运算符、Array.from() 和 concat()。这些方法都属于浅拷贝，足以应对数组只包含基本类型元素的情况。
如果数组中嵌套了对象或数组，浅拷贝就不够了。此时可以考虑使用 structuredClone() 进行深拷贝，或者借助 lodash 的 cloneDeep 等工具。需要注意的是，深拷贝的成本较高，尤其对于大体积或深层嵌套数据。因此更推荐的做法是从设计上避免共享可变数组，例如使用不可变数据结构，或者将数组封装在类中，通过专门的方法来修改，外部无法直接操作引用。
下面是一个简单的封装示例：
class SafeStack {
constructor() {
this._items = [];
}
push(item) {
this._items.push(item);
}
pop() {
return this._items.slice().pop();
}
get items() {
return [...this._items];
}
}
const stack = new SafeStack();
stack.push(1);
stack.push(2);
const removed = stack.pop();
console.log(removed); // 2
console.log(stack.items); // [1]
这个 SafeStack 类内部维护数组，但对外暴露的 pop() 方法先在副本上调用 pop()，因此不会修改内部存储的数组。items 的 getter 也返回副本，防止外部直接修改内部数组。这种封装方式牺牲了一点性能，但换来了数据流的可预测性。在大型应用中，这种防御性编程能有效减少因引用共享导致的诡异 bug。
最后需要强调，pop() 本身没有问题，问题往往出现在对引用类型特性的理解不足。当你明确知道一个数组是私有数据时，直接使用 pop() 高效且简洁；当数组可能被多个部分共享时，先复制再操作是更稳妥的选择。掌握这些边界，才能真正驾驭 pop() 以及 JavaScript 中一系列原地修改方法。
JavaScript pop()方法数组修改引用类型修改时间：2026-09-27 11:00:13