1、交集

记A，B是两个集合，以属于A且属于B的元素为元素的集合称为A与B的交（集），记作A∩B（或B∩A）

A∩B={x∣x∈A,且x∈B}

方法一：filter + includes

// A∩B={x∣x∈A,且x∈B}
const arr1 = ['1', '2', '3', '4']
const arr2 = ['2', '4', '6', '8']
const arr = arr1.filter(e => arr2.includes(e))
console.log(arr) // ['2', '4']

解析：在arr1中筛选包含在arr2中的数据，即为交集。
 

方法二：concat + filter + includes + Set

// A∩B={x∣x∈A,且x∈B}
const arr1 = ['1', '2', '3', '4']
const arr2 = ['2', '4', '6', '8']
const array = arr1.concat(arr2).filter(e => arr1.includes(e) && arr2.includes(e))
const arr = [...new Set(array)]
console.log(arr) // ['2', '4']

解析：先将两个数组合并，再筛选出既属于arr1又属于arr2的数据，最后去重，即为交集。

2、并集

记A，B是两个集合，以属于A或属于B的元素为元素的集合称为A与B的并（集），记作A∪B（或B∪A）

A∪B={x∣x∈A,或x∈B}

方法一：concat + Set

// A∪B={x∣x∈A,或x∈B}
const arr1 = ['1', '2', '3', '4']
const arr2 = ['2', '4', '6', '8']
const arr = [...new Set(arr1.concat(arr2))]
console.log(arr) // ['1', '2', '3', '4', '6', '8']

解析：将两个数组合并，然后去重，即为并集。

方法二：concat + reduce

// A∪B={x∣x∈A,或x∈B}
const arr1 = ['1', '2', '3', '4']
const arr2 = ['2', '4', '6', '8']
const arr = arr1.concat(arr2).reduce((pre, cur) => {
    if (!pre.includes(cur)) {
        pre.push(cur)
    }
    return pre
}, [])
console.log(arr) // ['1', '2', '3', '4', '6', '8']

解析：先将两个数组合并，然后执行reduce函数，结果值的初始值设置为空数组 [] , 当当前数据不存在结果值数组里时，将当前数据push到结果值数组里，最后获得结果值数组，即为并集。

3、差集

记A，B是两个集合，则所有属于A且不属于B的元素构成的集合，叫做集合A减集合B(或集合A与集合B之差)，类似地，对于集合A、B，把集合{x∣x∈A,且x∉B}叫做A与B的差集。

A-B={x∣x∈A,且x∉B}

B-A={x∣x∈B,且x∉A}

方法一：concat + filter + includes

// A-B={x∣x∈A,且x∉B}
const arr1 = ['1', '2', '3', '4']
const arr2 = ['2', '4', '6', '8']
const arr = arr1.concat(arr2).filter(e => arr1.includes(e) && !arr2.includes(e))
console.log(arr) // ['1', '3']

 解析：先将两个数组合并，然后筛选不在arr1的或者不在arr2的，即为A-B的差集。

// B-A={x∣x∈B,且x∉A}
const arr1 = ['1', '2', '3', '4']
const arr2 = ['2', '4', '6', '8']
const arr = arr1.concat(arr2).filter(e => arr2.includes(e) && !arr1.includes(e))
console.log(arr) // ['6', '8']

解析：先将两个数组合并，然后筛选不在arr2的或者不在arr1的，即为B-A的差集。

4、补集

记A，U是两个集合，属于全集U不属于集合A的元素组成的集合称为集合A的补集，记作CuA，即CuA={x|x∈U,且x∉A}。

A并B的补集等于A的补集交B的补集

方法一：concat + filter + includes + ...

const arr1 = ['1', '2', '3', '4']
const arr2 = ['2', '4', '6', '8']
const array = arr1.concat(arr2)
const arr = [...array.filter(e => !arr1.includes(e)), ...array.filter(e => !arr2.includes(e))]
console.log(arr) // ['6', '8', '1', '3']

解析：先将两个数组合并，再分别筛选出不在arr1、不在arr2中的数据，连个数组合并，即为补集。

方法二：filter + includes + ...

const arr1 = ['1', '2', '3', '4']
const arr2 = ['2', '4', '6', '8']
const arr = [...arr1.filter(e => !arr2.includes(e)), ...arr2.filter(e => !arr1.includes(e))]
console.log(arr) // ['1', '3', '6', '8']

解析：在arr1中筛选出不在arr2中的数据，在arr2中筛选出不在arr1中的数据，两个数组合并，即为补集。

5、es6方法解析

concat() 方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。

filter()方法创建给定数组一部分的浅拷贝，其包含通过所提供函数实现的测试的所有元素。

includes() 方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回 false。

reduce() 方法对数组中的每个元素按序执行一个由您提供的 reducer 函数，每一次运行 reducer 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值。

Set 对象允许你存储任何类型的唯一值，无论是原始值或者是对象引用。

... 展开语法 (Spread syntax), 可以在函数调用/数组构造时，将数组表达式或者 string 在语法层面展开；还可以在构造字面量对象时，将对象表达式按 key-value 的方式展开。(字面量一般指 [1, 2, 3] 或者 {name: "mdn"} 这种简洁的构造方式)