深入理解 Lodash _.intersection() 方法：从基础到实战应用

在日常的前端开发中，我们经常需要处理数据集合的比对问题。你是否遇到过需要从多个列表中筛选出“共有项”的情况？比如，我们要找出“既有权限A又有权限B的用户”，或者从多个商品标签中找出核心交集。虽然原生的 JavaScript 已经非常强大，但在处理这类数组交集问题时，直接编写循环去重不仅代码冗长，还容易出错。

这时候，Lodash 就成了我们工具箱里的得力助手。今天，我们将深入探讨 Lodash 中的 _.intersection() 方法。这不仅仅是一个简单的取交集函数，掌握它能让我们的数据操作代码更简洁、更易读，同时也更具鲁棒性。在这篇文章中，我们将结合2026年的技术背景，从基础用法到生产级性能优化，一起学习它的核心概念，以及在各种复杂场景下如何通过它来优化我们的代码逻辑。

2026年技术视野下的集合操作

你可能听说过“氛围编程”或 AI 辅助开发的浪潮。在 2026 年，我们编写代码的方式已经发生了深刻变化。当我们使用 Cursor 或 Windsurf 等 AI IDE 时，清晰地表达“意图”变得比单纯写出“语法”更重要。

_.intersection 之所以在今天依然重要，是因为它准确地封装了“求交集”这一高层意图。当我们告诉 AI 协助者“过滤出同时在 A 组和 B 组的数据”时，底层生成的逻辑往往正是这种高效的集合运算。理解其背后的原理，能帮助我们更好地审查 AI 生成的代码，确保它在生产环境中的性能表现符合预期。

什么是 _.intersection()？

简单来说，_.intersection() 方法用来计算数组的交集。这就像我们在数学集合论中学到的概念一样：给定两个集合 A 和 B，它们的交集是包含所有既属于 A 又属于 B 的元素的新集合。在 Lodash 中，这个方法会创建一个包含所有传入数组中共有元素的新数组，且结果的顺序取决于它们在第一个数组中出现的顺序。

核心语法与基本用法

在开始写代码之前，让我们先快速看一下它的语法结构：

_.intersection([arrays]);

为了让你更直观地理解，让我们从最简单的两个数组的交集开始。

#### 示例 1：寻找两个数组的交集

假设我们有两个列表，我们想找出它们共同拥有的数字。如果不使用工具函数，我们可能需要写双重循环。但现在，我们只需要一行代码。

// 引入 lodash 库
const _ = require("lodash");

// 原始数组定义
let array1 = [1, 2, 4, 3, 4, 4];
let array2 = [2, 4, 5, 6];

// 使用 _.intersection() 方法计算交集
// 即使 array1 中有重复的 4，结果中也只会保留一份
let newArray = _.intersection(array1, array2);

// 打印原始数组，验证原数据未被修改
console.log("原始数组 Array1: ", array1);
console.log("原始数组 Array2: ", array2);

// 打印生成的新数组
// 预期结果: [2, 4]
console.log("计算交集后的新数组: ", newArray);

在这个例子中，你需要注意两点：

• 去重机制：注意 INLINECODEf98a4ce6 中有三个 INLINECODE2fbb4c84，但结果数组中只有一个 4。这是因为它计算的是“集合”意义上的交集，不需要重复的项。
• 顺序保持：结果中的 INLINECODE71c1e2a5 在 INLINECODE380acf39 前面，这是因为它们在第一个参数 array1 中原本就是按这个顺序出现的。

#### 示例 2：多数组的复杂交集

在实际业务中，我们可能不仅要对比两个列表，而是要找出多个列表中都存在的“核心数据”。比如，同时满足条件 A、条件 B 和条件 C 的数据。

让我们看看如何处理三个数组的交集：

// 引入 lodash 库
const _ = require("lodash");

// 定义三个不同的数组
let array1 = [1, 2, 4, 3, 4, 4]; // 包含 1, 2, 3, 4
let array2 = [2, 4, 5, 6];        // 包含 2, 4, 5, 6
let array3 = [2, 3, 5, 6];        // 包含 2, 3, 5, 6

// 使用 _.intersection() 同时处理三个数组
// 只有同时存在于这三个数组中的元素才会被保留
let newArray = _.intersection(array1, array2, array3);

// 打印结果
// 预期结果: [2] (因为只有 2 同时存在于这三个数组中)
console.log("三个数组的交集结果: ", newArray);

深入解析：对象数组的陷阱与 _.intersectionBy

这是新手最容易踩坑的地方，也是我们在企业级项目中处理复杂数据结构时的关键技巧。

#### 对象数组的陷阱

让我们来看一个例子：

const _ = require("lodash");

// 原始数组：包含对象
let users1 = [{ ‘id‘: 1, ‘name‘: ‘Alice‘ }, { ‘id‘: 2, ‘name‘: ‘Bob‘ }];
let users2 = [{ ‘id‘: 1, ‘name‘: ‘Alice‘ }, { ‘id‘: 3, ‘name‘: ‘Charlie‘ }];

// 尝试直接使用 _.intersection
let commonUsers = _.intersection(users1, users2);

// 打印结果
// 你可能期待找到 Alice，但实际结果是 []
console.log("对象数组交集结果: ", commonUsers);

为什么会这样？

在 JavaScript 中，对象是引用类型。INLINECODEfdc01d39 中的 INLINECODEc8091c59 和 INLINECODE7090c422 中的 INLINECODE165ebcb9 虽然内容看起来一样，但它们在内存中是两个不同的地址。Lodash 默认不会去深度比较对象的属性，只会比较引用。

最佳实践：使用 _.intersectionBy

为了解决这个问题，我们需要告诉 Lodash：“请根据 INLINECODEaa43a7de 这个属性来判断它们是否相等”。这时候，我们需要升级使用 INLINECODEb4d54ab5。

const _ = require("lodash");

// 原始数组
let users1 = [{ ‘id‘: 1, ‘name‘: ‘Alice‘ }, { ‘id‘: 2, ‘name‘: ‘Bob‘ }];
let users2 = [{ ‘id‘: 1, ‘name‘: ‘Alice‘ }, { ‘id‘: 3, ‘name‘: ‘Charlie‘ }];

// 使用 _.intersectionBy，并指定迭代器函数为取 user.id
// 这样比较的就是 1 和 1，而不是对象引用
let commonUsers = _.intersectionBy(users1, users2, ‘id‘);

// 打印结果
// 预期结果: [{ ‘id‘: 1, ‘name‘: ‘Alice‘ }]
// 注意：返回的对象引用自 users1
console.log("基于 ID 的对象数组交集: ", commonUsers);

生产环境进阶：性能与数据规模决策

作为经验丰富的开发者，我们不能只看功能实现，必须关注性能边界。在现代 Web 应用中，尤其是在处理边缘计算或大规模数据筛选时，算法的选择至关重要。

#### 1. 性能对比：Lodash vs 原生 Set

虽然 Lodash 很方便，但如果你处理的是包含 10 万+ 条数据的原始值数组，使用原生 ES6 INLINECODEe23a1994 和 INLINECODE30419a3b 的组合通常比 Lodash 更快。这是因为 Set.has() 的时间复杂度接近 O(1)，而 Lodash 的旧版本实现可能涉及多次遍历。

// 极高性能要求的场景（原生 JS 方案）
const bigArray1 = [/* ... 10万条数据 ... */];
const bigArray2 = new Set([/* ... 10万条数据 ... */]);

// 使用 Set 进行内存筛选，速度极快
const intersection = [...new Set(bigArray1)].filter(x => bigArray2.has(x));

我们的建议：对于普通业务逻辑（几千条数据），请继续使用 INLINECODEcba20bed，因为它语义清晰且代码可读性高。但在处理大数据流或实时数据高频处理时，考虑重构为原生 INLINECODE28da538e 方案。

#### 2. 高级用法：自定义迭代器与复杂对象

在 2026 年的复杂应用中，我们常需要根据多维度条件计算交集。_.intersectionBy 允许传入一个函数，这给了我们极大的灵活性。

const _ = require("lodash");

// 场景：找出既属于“活跃用户”又符合“特定地理位置”重叠的用户
// 假设我们通过复杂的哈希算法来匹配地理位置
const activeUsers = [
  { ip: ‘192.168.1.1‘, role: ‘admin‘ },
  { ip: ‘192.168.1.2‘, role: ‘user‘ }
];

const geoBlockedUsers = [
  { ip: ‘192.168.1.1‘, role: ‘admin‘ }, // 重复的 admin
  { ip: ‘10.0.0.1‘, role: ‘guest‘ }
];

// 我们只想根据 IP 地址来判断是否为同一用户，忽略 role 的差异
let commonUsers = _.intersectionBy(activeUsers, geoBlockedUsers, (user) => {
  // 这里可以包含复杂的解析逻辑
  return user.ip; 
});

console.log(commonUsers);
// 输出: [{ ‘ip‘: ‘192.168.1.1‘, ‘role‘: ‘admin‘ }]

常见错误与避坑指南

错误 1：期望修改原数组

很多新手会误以为这个方法会修改原数组。记住： Lodash 的这类方法大多是纯函数，它返回一个新数组，绝不改变输入的参数。如果你想把结果赋值回去，记得显式地覆盖原变量。

错误 2：混用不同类型的数字

JavaScript 中 INLINECODEe696e255（数字）和 INLINECODE6a7efac2（字符串）是不等的。如果你的数组中有类型不一致的情况，_.intersection 会正确地将它们识别为不同的项而不会匹配。如果你希望它们被匹配，需要在处理前先统一数据类型（例如全部转成字符串）。

总结与后续步骤

在这篇文章中，我们深入探索了 Lodash 的 _.intersection() 方法。从基础的语法到处理多个数组，再到对象数组的深度比较技巧，相信你现在对如何处理数组交集有了全面的认识。

掌握这个方法，能让你在处理列表比对、数据筛选和权限校验等逻辑时，写出比原生循环更优雅、更健壮的代码。

你可以尝试的下一步操作：

• 尝试在你的现有项目中寻找那些复杂的 INLINECODEc4ee32e7 和 INLINECODEb00f3761 组合逻辑，看看是否可以用 INLINECODE1f5bab61 或 INLINECODEb6b2f223 来重构。
• 了解 Lodash 中的 INLINECODEdc3e7291（差集）和 INLINECODEaedc8634（对称差集）方法，完善你的集合操作工具箱。

希望这篇文章能帮助你更好地理解和使用 Lodash。编程愉快！