各位观众老爷，晚上好！我是今晚的讲师，代号“代码挖掘机”。今天咱要聊的是JavaScript里一个挺有意思的提案，叫做“Mathematical Set Operations”（数学集合运算）。这玩意儿听着高大上，其实就是给JS的Set对象加点新功能，让它能像数学课本里的集合一样，做并集、交集、差集等等操作。
为啥要聊这个呢？因为它能让你的代码更简洁、更高效，还能让你在面试的时候显得更博学（手动狗头）。当然，更重要的是，理解这些集合运算的效率，能让你写出性能更好的代码。咱们今天就来好好扒一扒这个提案，看看它到底有啥好东西，以及它们的Big O复杂度都是啥。
一、Set对象回顾：老朋友，新用法
首先，咱们简单回顾一下Set对象。这玩意儿是ES6引入的，它可以让你存储一组唯一的值。啥叫唯一？就是说Set里不能有重复的元素。如果你往Set里加了重复的值，它会自动去重。
const mySet = new Set([1, 2, 3, 4, 5]);
console.log(mySet); // 输出：Set(5) {1, 2, 3, 4, 5}
mySet.add(3); // 尝试添加重复的值
console.log(mySet); // 输出：Set(5) {1, 2, 3, 4, 5}，3并没有被重复添加Set对象有一些常用的方法，比如：
add(value): 添加一个值。delete(value): 删除一个值。has(value): 检查是否存在某个值。clear(): 清空Set。size: 返回Set的大小。
这些方法的时间复杂度基本上都是O(1)，也就是说，无论Set有多大，这些操作都很快。
二、Mathematical Set Operations提案：集合运算大礼包
现在，咱们进入正题。这个提案给Set对象增加了四个新的方法：
Set.prototype.union(other): 并集Set.prototype.intersection(other): 交集Set.prototype.difference(other): 差集Set.prototype.symmetricDifference(other): 对称差集
这些方法都接受另一个Set对象作为参数，并返回一个新的Set对象，表示运算结果。
下面咱们一个一个来看：
1. union(other)：并集
并集就是把两个Set里的所有元素都放到一个新的Set里。如果两个Set有相同的元素，只保留一个。
const setA = new Set([1, 2, 3]);
const setB = new Set([3, 4, 5]);
const unionSet = setA.union(setB);
console.log(unionSet); // 输出：Set(5) {1, 2, 3, 4, 5}实现方式及Big O分析：
最简单的实现方式就是遍历两个Set，把所有元素都添加到一个新的Set里。
Set.prototype.union = function(other) {
const newSet = new Set(this); // 先复制一份this Set
for (const item of other) {
newSet.add(item);
}
return newSet;
};- 时间复杂度： 假设
this的大小是n，other的大小是m。 复制this Set为O(n)，然后遍历other需要O(m)的时间，每次add操作是O(1)。所以总的时间复杂度是O(n + m)。 - 空间复杂度： 创建了一个新的
Set，大小最大可能是n + m，所以空间复杂度是O(n + m)。
2. intersection(other)：交集
交集就是找到两个Set里都有的元素，放到一个新的Set里。
const setA = new Set([1, 2, 3]);
const setB = new Set([3, 4, 5]);
const intersectionSet = setA.intersection(setB);
console.log(intersectionSet); // 输出：Set(1) {3}实现方式及Big O分析：
遍历一个Set，然后检查另一个Set里是否有相同的元素。
Set.prototype.intersection = function(other) {
const newSet = new Set();
for (const item of this) {
if (other.has(item)) {
newSet.add(item);
}
}
return newSet;
};- 时间复杂度： 假设
this的大小是n，other的大小是m。 遍历this需要O(n)的时间，每次has操作是O(1)。所以总的时间复杂度是O(n)。注意这里我们假设other的has()操作是 O(1) 的，这是Set的特性。如果other是一个数组，has()操作的时间复杂度就会变成 O(m)，总的时间复杂度就会变成 O(n * m)。 - 空间复杂度： 创建了一个新的
Set，大小最大可能是min(n, m)，所以空间复杂度是O(min(n, m))。
3. difference(other)：差集
差集就是找到只在第一个Set里有，不在第二个Set里的元素，放到一个新的Set里。
const setA = new Set([1, 2, 3]);
const setB = new Set([3, 4, 5]);
const differenceSet = setA.difference(setB);
console.log(differenceSet); // 输出：Set(2) {1, 2}实现方式及Big O分析：
遍历第一个Set，然后检查第二个Set里是否有相同的元素。
Set.prototype.difference = function(other) {
const newSet = new Set();
for (const item of this) {
if (!other.has(item)) {
newSet.add(item);
}
}
return newSet;
};- 时间复杂度： 假设
this的大小是n，other的大小是m。 遍历this需要O(n)的时间，每次has操作是O(1)。所以总的时间复杂度是O(n)。 - 空间复杂度： 创建了一个新的
Set，大小最大可能是n，所以空间复杂度是O(n)。
4. symmetricDifference(other)：对称差集
对称差集就是找到只在一个Set里有，不在另一个Set里的元素，放到一个新的Set里。 换句话说，就是 (A – B) ∪ (B – A)。
const setA = new Set([1, 2, 3]);
const setB = new Set([3, 4, 5]);
const symmetricDifferenceSet = setA.symmetricDifference(setB);
console.log(symmetricDifferenceSet); // 输出：Set(4) {1, 2, 4, 5}实现方式及Big O分析：
可以先计算差集，然后再计算反过来的差集，最后把两个差集做并集。
Set.prototype.symmetricDifference = function(other) {
const difference1 = this.difference(other);
const difference2 = other.difference(this);
return difference1.union(difference2);
};- 时间复杂度： 假设
this的大小是n，other的大小是m。difference操作都是 O(n) 和 O(m)，union操作是 O(n + m)。所以总的时间复杂度是 O(n) + O(m) + O(n + m) = O(n + m)。 - 空间复杂度： 创建了多个新的
Set，大小最大可能是n + m，所以空间复杂度是O(n + m)。
三、效率优化：一点小技巧
虽然上面这些实现方式已经很简单了，但有些情况下，我们还可以做一些小小的优化。
1. 选择合适的遍历对象
在计算交集和差集的时候，我们总是遍历第一个Set。但如果第一个Set比第二个Set大很多，遍历第二个Set可能会更快。
Set.prototype.intersection = function(other) {
const smallerSet = this.size <= other.size ? this : other;
const largerSet = this.size <= other.size ? other : this;
const newSet = new Set();
for (const item of smallerSet) {
if (largerSet.has(item)) {
newSet.add(item);
}
}
return newSet;
};这样，我们遍历的就是更小的Set，可以稍微提高一点效率。 当然，这种优化只在两个Set大小差异很大的时候才比较明显。
2. 利用现有API（如果可用）
如果你的JS环境已经支持这些方法了（比如最新的浏览器或者Node.js），那就直接用原生的API，不要自己实现。原生的API通常会做过很多优化，性能肯定比你自己写的要好。
四、Big O复杂度总结：一图胜千言
为了方便大家记忆，我把上面分析的Big O复杂度整理成一个表格：
| 方法 | 时间复杂度 | 空间复杂度 |
|---|---|---|
union(other) |
O(n + m) | O(n + m) |
intersection(other) |
O(min(n, m)) | O(min(n, m)) |
difference(other) |
O(n) | O(n) |
symmetricDifference(other) |
O(n + m) | O(n + m) |
- n：第一个
Set的大小 - m：第二个
Set的大小
五、实际应用场景：让代码更优雅
这些集合运算在实际开发中有很多用处。比如：
- 数据过滤： 假设你有一个用户列表，和一个黑名单列表，你可以用差集来过滤掉黑名单用户。
- 权限控制： 假设你有一个用户拥有的权限列表，和一个角色拥有的权限列表，你可以用并集来计算用户最终拥有的权限。
- 数据分析： 假设你有两个数据集，你可以用交集来找到两个数据集共有的数据。
总之，只要涉及到集合操作，这些方法就能派上用场。
六、注意事项：一些坑要避开
- 类型问题： 这些方法都要求参数是
Set对象。如果你传入了其他类型的参数，可能会报错。 - 兼容性问题： 这些方法是提案，不是所有JS环境都支持。在使用之前，最好先检查一下是否支持。
- 性能问题： 虽然这些方法的时间复杂度都不算太高，但如果你的
Set非常大，还是要注意性能问题。可以考虑使用一些更高效的算法或者数据结构。
七、总结：集合运算，代码利器
Mathematical Set Operations提案给JS的Set对象增加了很多实用的方法，让我们可以更方便地进行集合运算。理解这些方法的效率，能帮助我们写出性能更好的代码。希望今天的讲座能对大家有所帮助。
记住，代码就像挖掘机，学得好，就能挖到金矿！ 感谢各位观众老爷的观看，咱们下期再见！