两个集合的交集指的是同时出现在这两个集合中的元素。用数学术语来说，两个集合的交集表示为 A ∩ B。这意味着集合 A 和集合 B 中共有的所有元素都应该出现在一个数组中。在 JavaScript 中，两个集合的交集意味着我们要从两个集合中提取出公共的部分。
我们可以通过多种方式来找到两个集合的交集：
- JavaScript Sets（集合）： Set 可以存储任何类型的值，无论是原始值还是对象。
- JavaScript filter() 方法： 从给定数组创建一个新数组，其中仅包含满足参数方法设定的条件的那些元素。
- JavaScript set.has() 方法： 检查具有指定值的元素是否存在于 Set 中。
使用 Sets 和 has() 方法： Set 是唯一项的集合，即没有元素可以重复。ES6 中的 Set 是有序的：集合的元素可以按照插入顺序进行迭代。Set 可以存储任何类型的值，无论是原始值还是对象。
示例 1： 在这个示例中，我们将看到如何使用 set.has() 方法来求集合的交集。
JavaScript
function getIntersection(set1, set2) {
const ans = new Set();
for (let i of set2) {
if (set1.has(i)) {
ans.add(i);
}
}
return ans;
}
const set1 = new Set([1, 2, 3, 8, 11]);
const set2 = new Set([1, 2, 5, 8]);
const result = getIntersection(set1, set2);
console.log(result);
输出：
Set(3) { 1, 2, 8 }
使用 has() 和 filter() 方法： 我们会检查元素是否也存在于 set1 中，如果是，我们就将该元素添加到新的集合中。
示例 2： 在这个示例中，我们将看到如何使用 filter() 方法来求集合的交集。我们还使用了 扩展运算符 来分离元素。
JavaScript
let set1 = new Set([1, 2, 3]);
let set2 = new Set([4, 3, 2]);
let set = new Set([...set1].filter(x => set2.has(x)));
console.log(set);
输出：
Set(2) { 2, 3 }
2026 开发者视角：从基础语法到工程化实践
当我们站在 2026 年的视角回顾这些基础操作时，你会发现虽然核心 API（如 INLINECODEe79d4498 和 INLINECODEb03e98a7）没有改变，但我们对性能、可读性以及代码生成能力的理解已经发生了深刻的变化。在现代的前端工程中，我们不仅仅是在写代码，更是在与 AI 协作，构建高可用、高性能的系统。让我们深入探讨一下，在现代化的开发工作流中，我们如何重新审视“集合交集”这个看似简单的问题。
生产环境下的性能深度剖析
你可能会问，上述两种方法在实际项目中有什么区别？让我们思考一下这个场景：当我们处理数百万级别的数据集合时。
- 方法 1 (显式循环)：通常效率更高，因为它直接利用了 Set 的 $O(1)$ 查找特性，并且避免了创建中间数组（
[...set1]的开销）。 - 方法 2 (filter + 扩展运算符)：语法非常优雅，这就是我们常说的“声明式编程”。在处理小型数据集时，它的可读性优势远大于微小的性能损耗。
在我们最近的一个大型数据可视化项目中，我们需要对来自两个不同 WebSocket 数据源的实时 ID 列表进行去重和匹配。起初我们使用了 INLINECODEb40f8f35 方法，但在数据量激增时，主线程出现了明显的卡顿（Jank）。通过 Chrome DevTools 的 Performance 面板分析，我们发现内存分配（Allocation）成为了瓶颈。因此，我们将核心算法回退到了类似“方法 1”的高性能循环实现，并配合 INLINECODE50a03d3c 进行分片处理。这告诉我们：代码不仅要写得优雅，更要符合数据的物理特性。
现代 JavaScript：不仅是语法，更是工具链
到了 2026 年，我们使用像 Cursor 或 Windsurf 这样的 AI 原生 IDE（IDEs）。当我们输入“// Find intersection of two sets”时，AI 补全的往往是 filter 这种最简写法。作为经验丰富的开发者，我们的职责不仅是编写代码，更是审查 AI 生成的代码。
我们需要训练我们的 AI 结对编程伙伴，让它理解我们的上下文。例如，在生成代码时，我们可以通过注释引导 AI 生成更健壮的版本：
// AI Context: We are dealing with massive datasets in a Node.js service.
// Priority: Memory efficiency over brevity.
// Please implement a high-performance intersection function.
/**
* 高性能交集计算器
* @param {Set} setA - 第一个集合
* @param {Set} setB - 第二个集合
* @returns {Set} 交集结果
*/
function getIntersectionOptimized(setA, setB) {
// 策略：总是迭代较小的集合，以减少循环次数
const [smaller, larger] = setA.size < setB.size ? [setA, setB] : [setB, setA];
const intersection = new Set();
for (const item of smaller) {
if (larger.has(item)) {
intersection.add(item);
}
}
return intersection;
}
在这个例子中，我们利用了一个简单的算法优化：总是遍历较小的集合。这是一个典型的工程化决策，AI 可能不会默认这样做，但作为人类专家，我们必须指出来。
现代架构中的应用：边缘计算与 Serverless
让我们思考一下这个场景：在 Serverless 或 Edge Computing（边缘计算）环境中。
在这些环境中，冷启动时间和内存限制是极其关键的。虽然 Set 是内置对象，其创建成本极低，但如果你处理的是像 JSON 这样的大对象，序列化和反序列化可能会成为瓶颈。在一些极端的高性能边缘节点（如 Cloudflare Workers）中，我们可能会遇到 CPU 时间限制。
如果数据是原始值的数组（例如用户 ID 列表），我们通常会将它们转换为 Set 以利用 $O(1)$ 的查找速度。但如果数据是对象数组呢？
// 处理对象数组的交集（基于某个键）
const usersA = [{ id: 1, name: ‘Alice‘ }, { id: 2, name: ‘Bob‘ }];
const usersB = [{ id: 2, name: ‘Robert‘ }, { id: 3, name: ‘Charlie‘ }];
// 传统的两步法：建立查找表 -> 过滤
function getObjectIntersection(arr1, arr2, key) {
// 创建一个临时的 Set 用于快速查找，这是空间换时间（Space-Time Trade-off）的经典案例
const lookup = new Set(arr2.map(item => item[key]));
return arr1.filter(item => lookup.has(item[key]));
}
console.log(getObjectIntersection(usersA, usersB, ‘id‘));
// 输出: [{ id: 2, name: ‘Bob‘ }]
在这里，我们面临着技术债务的考量： 为了查找速度，我们额外消耗了 $O(N)$ 的内存来构建 lookup Set。在内存受限的边缘环境中，如果数据集过大，这种策略可能会导致 OOM（Out of Memory）。因此，我们必须在开发初期就通过监控工具（如 V8 的堆快照）来评估这种权衡。
容灾与防御性编程：TypeScript 的角色
作为 2026 年的开发者，我们几乎完全生活在 TypeScript 的世界里。上述的 JavaScript 代码虽然能运行，但在类型安全上存在漏洞。在“安全左移”的开发理念下，我们不仅要写对代码，还要让编译器帮助我们防止错误。
让我们为之前的 getIntersection 函数添加严格的类型定义和边界检查：
/**
* 计算两个泛型集合的交集
* @throws {Error} 如果输入参数不是 Set 实例
*/
function safeIntersection(setA: Set, setB: Set): Set {
// 防御性编程：确保输入的有效性
if (!(setA instanceof Set) || !(setB instanceof Set)) {
throw new TypeError(‘Arguments must be instances of Set‘);
}
// 边界情况优化：如果任一集合为空，直接返回空集合
if (setA.size === 0 || setB.size === 0) {
return new Set();
}
return new Set([...setA].filter(item => setB.has(item)));
}
通过引入泛型 `INLINECODE380bb946SetINLINECODE0c673d35filterINLINECODE4b709d53hasINLINECODE25bba416set.intersection` 时，希望你能联想到这背后的整个技术图谱。编程不再仅仅是关于语法，更是关于在复杂的系统中做出最优的决策。