JS数组按值删除指定元素的方法

作者:代码拾荒

时间:2026-11-19

浏览:568

深入讲解 JavaScript 中按值删除数组指定元素的实用方法与核心机制,覆盖 indexOf 与 splice 的单次安全删除、filter 不可变过滤、循环删除中的索引塌陷陷阱与倒序遍历、双指针原地覆盖法以及对象数组与批量删除场景选型。

文章目录
JavaScript 教程 阅读时间:约 8 分钟 适用环境:ECMAScript 5+ / 现代浏览器 / Node.js
JS数组按值删除指定元素的方法
在日常 JavaScript 开发中,按值删除数组元素是一项基础且高频的操作。然而与部分其他高级语言不同,JavaScript 原生 Array 原型链上并未提供类似 arr.remove(value) 的直接语法糖,内置的原生删除方法(如 splice、pop、shift)均以索引或物理位置为操作基准。因此,按值删除的核心逻辑必定包含“先查找定位,再执行剔除”两步。根据具体业务中是否允许改变原数组,该操作主要划分为两大技术流派:原地修改(In-Place Mutation)与不可变过滤(Immutable Filtering)。

一、基础原地删除:indexOf 配合 splice(单次删除)

如果业务场景明确要求直接在原数组上剔除元素,且只删除出现的第一个匹配项,最标准且语义直接的做法是结合使用 indexOf() 和 splice()。

indexOf(value) 采用严格相等(===)从数组左侧向右侧检索指定值。若找到匹配项,返回对应的非负索引;若未找到,则返回 -1。得到合法索引后,调用 splice(index, 1) 即可原地切除该位置上的 1 个元素。

// 示例:原地删除数组中的第一个指定值
const fruits = ['apple', 'banana', 'cherry', 'date'];
const targetValue = 'cherry';

const index = fruits.indexOf(targetValue);

// 核心防御:必须严谨判断 index !== -1
if (index !== -1) {
  fruits.splice(index, 1);
}

console.log(fruits); 
// 输出: ['apple', 'banana', 'date']
关键避坑点:严禁遗漏 index !== -1 校验!
在 JavaScript 中,Array.prototype.splice() 允许接收负数作为起始索引,表示从数组末尾倒数计算。如果目标值在数组中不存在,indexOf 将返回 -1。若未经判断直接调用 fruits.splice(-1, 1),代码不会报错,而是会默默将数组的最后一个元素切除,从而引发隐蔽的业务逻辑 Bug。
JS数组按值删除指定元素的方法
图 1:indexOf 与 splice 组合定位并切除目标元素的四步执行流程

二、标准不可变删除:使用 filter 生成新数组(批量删除)

在以 React、Vue 3 或 Redux 为代表的现代前端技术栈中,遵循数据不可变性(Immutability)是状态管理的核心原则。此时我们通常不希望直接修改原数组的内存块,而是希望生成一个排除掉目标值后的全新数组。

Array.prototype.filter() 接受一个断言回调函数,遍历数组的每一个元素,仅保留回调返回值为真(true)的项,并将其浅拷贝放入新数组中。利用不等于断言 item !== targetValue,可以一行代码剔除所有匹配项:

// 示例:利用 filter 不可变剔除所有匹配值
const list = ['vue', 'react', 'angular', 'react', 'svelte'];
const itemToRemove = 'react';

const filteredList = list.filter(item => item !== itemToRemove);

console.log(filteredList); 
// 输出: ['vue', 'angular', 'svelte']
console.log(list); 
// 原数组依然完整: ['vue', 'react', 'angular', 'react', 'svelte']

filter() 具备两个显著特征:

  1. 自动剔除所有重复项:如果数组中存在多个与目标相等的元素,filter() 会统一全部剔除,无需像 splice 那样手动编写循环。
  2. 零副作用(Pure Function):原数组引用的堆内存内容完全不被篡改。在 React 组件中,这种产生新引用的机制能被 Object.is 准确捕获,从而正确触发视图重渲染。
JS数组按值删除指定元素的方法
图 2:原地修改 (splice) 与不可变过滤 (filter) 的内存引用与副作用差异对比

三、原地删除全部匹配项:遍历中的“索引塌陷”陷阱与解法

当遇到“既要原地修改原数组,又要删除其中所有重复匹配值”的需求时,许多开发者容易写出如下的正向 for 循环搭配 splice 代码:

// ❌ 典型错误示范:正向遍历直接 splice 会导致连续项漏删
const numbers = [1, 2, 2, 3];
for (let i = 0; i < numbers.length; i++) {
  if (numbers[i] === 2) {
    numbers.splice(i, 1);
  }
}
console.log(numbers); 
// 预期是 [1, 3],实际输出却是 [1, 2, 3]!第二个 2 被漏删了

出现这一现象的原因在于索引塌陷(Index Shift):当 i = 1 时切除了第一个 2,原本位于 i = 2 处的第二个 2 会立刻向前平移滑落到 i = 1 处;然而循环体下一轮自增使 i 变成了 2,检查的实际上是原本处于末尾的数字 3,从而导致刚刚滑落到索引 1 的目标值被直接跳过。

解法 1:倒序遍历(从尾至头检查)

最简单直接的修复方案是将遍历方向改为倒序。因为 splice 仅会影响被删除索引右侧(后续)元素的下标,而从右向左遍历时,尚未检查的元素均位于被删除元素的左侧,其下标绝对不会受到波及:

const numbers = [1, 2, 2, 3];

for (let i = numbers.length - 1; i >= 0; i--) {
  if (numbers[i] === 2) {
    numbers.splice(i, 1);
  }
}

console.log(numbers); // 输出: [1, 3],成功完整删除

解法 2:while 循环结合 indexOf(适合少量重复项)

const tags = ['js', 'css', 'html', 'css'];
let idx;
while ((idx = tags.indexOf('css')) !== -1) {
  tags.splice(idx, 1);
}

解法 3:高性能双指针原地覆盖法(大规模数据最优解)

需要注意,上述倒序循环或 while 循环在处理成千上万个元素的大数组时存在性能隐患:每一次 splice 操作,V8 引擎底层都要将后续全部元素在内存中向前平移一次。若删除 $K$ 个元素,总时间复杂度会退化为 $O(N imes K)$,最差情况为 $O(N^2)$。

针对大规模数据,经典算法方案是快慢双指针原地覆盖(Two-Pointers Compaction):利用读指针 read 扫描数组,遇到保留元素就写入写指针 write 所在位置;遍历完毕后,直接修改 arr.length = write 截断多余元素。全程仅需单次 $O(N)$ 扫描,空间复杂度保持 $O(1)$:

// 高性能原地批量删除函数
function removeInPlace(arr, target) {
  let write = 0;
  for (let read = 0; read < arr.length; read++) {
    if (arr[read] !== target) {
      arr[write] = arr[read];
      write++;
    }
  }
  // 原地直接收缩数组长度,底层瞬间释放末尾多余槽位
  arr.length = write;
  return arr;
}

const data = [1, 2, 2, 3, 2, 4];
removeInPlace(data, 2);
console.log(data); // 输出: [1, 3, 4]
JS数组按值删除指定元素的方法
图 3:正向循环的“索引塌陷”漏删成因 与 双指针原地覆盖法原理剖析

四、进阶场景:对象数组与多值批量排除

1. 对象数组按属性值删除

在实际工程中,数组中存放的往往是对象实体。由于 JavaScript 中对象采用引用地址比对(即使内容相同的两个字面量对象 {id: 1} !== {id: 1}),我们不能直接通过 indexOf({id: 1}) 定位。

原地删除方案:借助 findIndex() 传入谓词函数,找到匹配索引后再执行 splice:

const users = [
  { id: 101, name: 'Alice' },
  { id: 102, name: 'Bob' },
  { id: 103, name: 'Charlie' }
];

const targetId = 102;
const targetIdx = users.findIndex(user => user.id === targetId);

if (targetIdx !== -1) {
  users.splice(targetIdx, 1);
}

不可变方案:直接使用 filter() 匹配目标属性:

const remainingUsers = users.filter(user => user.id !== targetId);

2. 一次性批量删除多个指定值(基于 Set 提速)

若需要从一个长数组中剔除一个包含多个待删值的列表(例如剔除 [3, 5, 8, 9]),若对每个元素都执行数组的 includes,总复杂度为 $O(N imes M)$。最佳实践是先将待删列表构造为 Set 哈希集合,利用其 $O(1)$ 的检索效率:

const rawList = [1, 2, 3, 4, 5, 6, 7, 8];
const valuesToRemove = [2, 5, 7];

// 将排除列表转为 Set
const removeSet = new Set(valuesToRemove);

// 整体复杂度降低至 O(N)
const cleanList = rawList.filter(item => !removeSet.has(item));
console.log(cleanList); // 输出: [1, 3, 4, 6, 8]

五、方法综合对比与选型决策

不同的业务场景对内存、副作用和性能有完全不同的权衡需求。以下是各方法的关键指标对照:

方法组合 是否修改原数组 删除项数量 时间复杂度 空间复杂度 最佳推荐场景
indexOf + splice 是(原地修改) 仅首个匹配项 $O(N)$ $O(1)$ 基础类型单元素原地移除、唯一键列表
findIndex + splice 是(原地修改) 仅首个匹配项 $O(N)$ $O(1)$ 对象数组按复合条件或指定属性原地删除
filter() 否(生成新数组) 全部匹配项 $O(N)$ $O(N)$ React/Vue3 状态变更、不可变数据流首选
倒序 for + splice 是(原地修改) 全部匹配项 $O(N^2)$ $O(1)$ 中小规模数组的原地批量删除、代码直观
双指针原地覆盖法 是(原地修改) 全部匹配项 $O(N)$ $O(1)$ 大规模数据、高性能算法题或内存受限场景
Set + filter 否(生成新数组) 多值批量排除 $O(N + M)$ $O(N + M)$ 黑名单过滤、复杂集合批量差集运算
JS数组按值删除指定元素的方法
图 4:JavaScript 数组按值删除方法选型决策树

六、容易忽略的边界细节与排错清单

  • NaN 的比对陷阱:由于 JavaScript 中 NaN === NaN 返回 false,因此 arr.indexOf(NaN) 永远返回 -1,无法通过常规 indexOf 删除 NaN。若数组中含有 NaN,应使用 arr.findIndex(Number.isNaN) 或 arr.filter(x => !Number.isNaN(x)) 进行精确定位。
  • 数组空位(稀疏数组):若数组包含未初始化的空槽(empty slot),indexOf 会直接跳过空槽,而 filter 回调函数也不会对空槽执行,直接忽略该位置。
  • 响应式框架的拦截机制:在 Vue 2 中,splice 是被框架重写的变异方法,直接调用能触发视图更新,但直接给数组项重新赋值(如双指针覆盖 arr[write] = ...)可能丢失响应性;而在 React 中必须通过 filter 产生新引用才能让 useState 正确派发渲染。

实用工具推荐

电子包浆

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

使用 ›
图片压缩

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

使用 ›
相关文章