JS使用pullAll移除数组多个值的方法

本文深入探讨了在 JavaScript 中使用 Lodash 库的 `pullAll` 方法高效移除数组中多个特定值的方法。`_.pullAll` 能够直接修改原数组，接受一个数组和一个包含待移除值的数组作为参数，简化了代码并提升了性能。文章对比了 `pullAll` 与 `pull` 的区别，前者更适合处理动态值列表。同时，针对不修改原数组的需求，推荐使用 `_.without` 或原生 `filter` 方法。特别是在处理对象数组时，由于 `pullAll` 基于严格相等比较，推荐使用 `_.remove` 或 `filter` 配合判断函数，以避免对象引用问题，提高代码的可读性和准确性。掌握这些技巧，能更灵活地处理 JavaScript 数组操作，提升开发效率。

Lodash的pullAll方法可高效移除数组中多个特定值，它直接修改原数组，接受一个待操作数组和一个包含需移除值的数组作为参数，例如\_.pullAll(fruits, ['apple', 'banana'])会从fruits中移除所有匹配项；与pull的区别在于参数形式：pull接收多个独立值作为参数，如\_.pull(array, 'a', 'c')，而pullAll接收一个值数组，如\_.pullAll(array, ['a', 'c'])，更适合动态值列表的场景；若不想修改原数组，应使用\_.without或原生filter方法，前者需配合解构操作符使用，如\_.without(originalArray, ...valuesToRemove)，后者更灵活，支持复杂条件过滤，尤其适用于对象数组；处理对象数组时pullAll存在局限，因其基于严格相等（===）比较，只能通过传入数组中实际存在的对象引用才能成功移除，若按属性匹配删除应选用\_.remove或filter配合判断函数，如\_.remove(objects, obj => idsToRemove.includes(obj.id))或objects.filter(obj => !idsToRemove.includes(obj.id))，以避免引用不一致问题并提升代码可读性。

js 中要高效移除数组里的多个特定值，Lodash 库的 pullAll 方法是个非常直接且实用的选择。它能让你指定一个数组，以及一个包含所有待移除值的数组，然后直接修改原数组，省去不少循环和条件判断的麻烦。

Lodash 的 _.pullAll(array, values) 方法是实现这一目标的利器。它会直接修改传入的 array，将其中所有与 values 数组中任一元素相等的值都移除掉。

举个例子，假设你有一个水果列表，想把苹果和香蕉都从里面拿走：

const _ = require('lodash'); // 别忘了安装 Lodash：npm install lodash

let fruits = ['apple', 'banana', 'orange', 'apple', 'grape', 'banana'];
const valuesToRemove = ['apple', 'banana'];

_.pullAll(fruits, valuesToRemove);

console.log(fruits); // 输出: [ 'orange', 'grape' ]

你会发现 fruits 数组已经被原地修改了。这种直接操作原数组的特性，在某些场景下非常方便，但也需要注意，因为它有副作用。

pullAll 与 pull 的区别是什么？

很多人在 Lodash 中会遇到 pull 和 pullAll，它们看起来很像，但用起来还是有点微妙的区别。简单来说，pull 是用来移除你“一个个”明确列出的值，而 pullAll 则是批量处理，移除一个“列表”里的所有值。

比如说，你要移除一个数组里的 'a' 和 'c'：

使用 pull: _.pull(array, 'a', 'c') 使用 pullAll: _.pullAll(array, ['a', 'c'])

看，参数的形态就不一样了。pull 接受的是可变参数列表，而 pullAll 接受的是一个数组。

let letters1 = ['a', 'b', 'c', 'a', 'd'];
_.pull(letters1, 'a', 'c');
console.log('pull 后的结果:', letters1); // 输出: pull 后的结果: [ 'b', 'd' ]

let letters2 = ['a', 'b', 'c', 'a', 'd'];
_.pullAll(letters2, ['a', 'c']);
console.log('pullAll 后的结果:', letters2); // 输出: pullAll 后的结果: [ 'b', 'd' ]

虽然结果可能一样，但当你要移除的值是动态生成的一个列表时，pullAll 的优势就体现出来了，你不需要把数组里的每个元素都解构出来作为 pull 的参数。这是一个很实际的场景，尤其是在处理用户输入或者从数据库查询出来的需要过滤的数据时。

如果不想修改原数组，该如何实现类似 pullAll 的功能？

pullAll 的一个特点是它会原地修改原数组。这在一些性能敏感或者链式操作的场景下可能很方便，但如果你的代码风格更倾向于函数式编程，或者你需要保留原数组的完整性，那这种副作用就得小心了。

Lodash 也提供了不修改原数组的方法。对于移除特定值，_.without 是一个很好的选择，它返回一个新数组，不包含你指定的值。

const _ = require('lodash');

let originalNumbers = [1, 2, 3, 4, 5, 2, 6];
const valuesToExclude = [2, 4];

// 使用 _.without
let newNumbersWithout = _.without(originalNumbers, ...valuesToExclude); // 注意这里需要解构赋值
console.log('_.without 后的新数组:', newNumbersWithout); // 输出: _.without 后的新数组: [ 1, 3, 5, 6 ]
console.log('原数组是否改变:', originalNumbers); // 输出: 原数组是否改变: [ 1, 2, 3, 4, 5, 2, 6 ]

当然，你也可以直接用原生的 JavaScript filter 方法结合 includes 来实现。这通常更灵活，尤其是在移除对象数组中的特定对象时，因为 pullAll 和 without 默认是基于值相等性判断的。

let originalItems = [
    { id: 1, name: 'Item A' },
    { id: 2, name: 'Item B' },
    { id: 3, name: 'Item C' }
];
const itemsToRemoveIds = [1, 3];

// 使用 filter 和 includes
let filteredItems = originalItems.filter(item => !itemsToRemoveIds.includes(item.id));
console.log('filter 后的新数组:', filteredItems);
// 输出: filter 后的新数组: [ { id: 2, name: 'Item B' } ]
console.log('原数组是否改变:', originalItems);
// 输出: 原数组是否改变: [ { id: 1, name: 'Item A' }, { id: 2, name: 'Item B' }, { id: 3, name: 'Item C' } ]

这种方式的灵活性在于，你可以自定义过滤的逻辑，不仅仅是简单的值相等。比如说，移除所有 id 大于 5 的项，或者移除所有名字包含“测试”的项，filter 都能轻松应对。这在处理复杂数据结构时特别有用。

pullAll 在处理对象数组时有哪些需要注意的地方？

当你在数组里处理对象时，pullAll 的行为可能会让你有点困惑，因为它默认是使用严格相等（===）来比较值的。这意味着，如果你想移除一个对象，你必须传入那个数组中“确切的”对象引用，而不是一个仅仅内容看起来一样的“新”对象。

想象一下这个场景：

const _ = require('lodash');

let users = [
    { id: 1, name: 'Alice' },
    { id: 2, name: 'Bob' },
    { id: 3, name: 'Charlie' }
];

// 尝试移除 Bob，但传入的是一个新的对象实例
const bobToRemove = { id: 2, name: 'Bob' };
_.pullAll(users, [bobToRemove]);
console.log('尝试移除 Bob (新对象) 后的 users:', users);
// 输出: 尝试移除 Bob (新对象) 后的 users: [ { id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, name: 'Charlie' } ]
// 发现 Bob 还在，因为传入的 bobToRemove 和数组里的 { id: 2, name: 'Bob' } 是不同的内存地址。

要让 pullAll 工作，你必须传入数组中实际存在的那个对象：

let users2 = [
    { id: 1, name: 'Alice' },
    { id: 2, name: 'Bob' },
    { id: 3, name: 'Charlie' }
];

const actualBob = users2[1]; // 获取数组中 Bob 的实际引用
_.pullAll(users2, [actualBob]);
console.log('移除实际 Bob 引用后的 users2:', users2);
// 输出: 移除实际 Bob 引用后的 users2: [ { id: 1, name: 'Alice' }, { id: 3, name: 'Charlie' } ]
// 这次就成功了。

所以在处理对象数组时，如果你的目标是根据对象的某个属性（比如 id）来移除，pullAll 就不是最直接的工具了。这时候，通常会倾向于使用 Lodash 的 _.remove 或者原生的 filter 方法，它们允许你传入一个判断函数（predicate）。

使用 _.remove (会修改原数组):

let products = [
    { id: 101, name: 'Laptop' },
    { id: 102, name: 'Mouse' },
    { id: 103, name: 'Keyboard' }
];
const idsToRemove = [101, 103];

_.remove(products, product => idsToRemove.includes(product.id));
console.log('_.remove 后的 products:', products);
// 输出: _.remove 后的 products: [ { id: 102, name: 'Mouse' } ]

或者使用 filter (返回新数组，不修改原数组):

let articles = [
    { id: 201, title: 'JS Basics' },
    { id: 202, title: 'CSS Advanced' },
    { id: 203, title: 'React Hooks' }
];
const idsToFilterOut = [201, 203];

let remainingArticles = articles.filter(article => !idsToFilterOut.includes(article.id));
console.log('filter 后的 remainingArticles:', remainingArticles);
// 输出: filter 后的 remainingArticles: [ { id: 202, title: 'CSS Advanced' } ]
console.log('原 articles 数组:', articles);
// 输出: 原 articles 数组: [ { id: 201, title: 'JS Basics' }, { id: 202, title: 'CSS Advanced' }, { id: 203, title: 'React Hooks' } ]

在我看来，处理对象数组时，使用带判断函数的 _.remove 或 filter 几乎总是更清晰、更符合直觉的做法。它避免了对象引用带来的潜在陷阱，让你的代码意图表达得更明确。

到这里，我们也就讲完了《JS使用pullAll移除数组多个值的方法》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！