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几乎总是更清晰、更符合直觉的做法。它避免了对象引用带来的潜在陷阱，让你的代码意图表达得更明确。
