数组的集合运算

let arr1 = [1, 2, 3, 4, 5]
let arr2 = [4, 5, 6, 7, 8]
let arr1Set = new Set(arr1)
let arr2Set = new Set(arr2)
// 交集
// 1、数组遍历
let intersect1 = []
arr1.forEach(item => {
    if (arr2.includes(item)) {
        intersect1.push(item)
    }
})
console.log(intersect1)
// 2、使用Set
let intersect2 = new Set(arr1.filter(x => arr2Set.has(x)))
intersect2 = [...intersect2]
console.log(intersect2)
// 并集
// 1、数组遍历
let union1 = []
arr1.forEach(item => {
    if (!arr2.includes(item)) {
        union1.push(item)
    }
})
union1 = [...union1, ...arr2]
console.log(union1)
// 2、使用Set
let union2 = [...new Set([...arr1Set, ...arr2Set])]
console.log(union2)
// 差集
// 1、数组遍历
let arr1dif = []
let arr2dif = []
console.log(arr1)
console.log(arr2)
arr1.forEach(item => {
    if(!arr2.includes(item)) {
        arr1dif.push(item)
    }
})
arr2.forEach(item => {
    if(!arr1.includes(item)) {
        arr2dif.push(item)
    }
})
console.log(arr1dif)
console.log(arr2dif)
// 2、Set
let dif1 = new Set(arr1.filter(x => !arr2Set.has(x)))
let dif2 = new Set([...arr2Set].filter(x => !arr1Set.has(x)))
console.log(dif1)
console.log(dif2)

// 数组扩展运算符去重
let list = [1, 1, 2, 3, 4, 4]
list = [...new Set(list)]
console.log(list)

// 扩展运算符合并数组
array = [...arr1, ...arr2]
console.log(array)

// 扩展运算符将字符串转化为数组
let strArr = [...'hello']
console.log(strArr)

// 扩展运算符将Set结构，Map结构转化为数组
let set = new Set([7, 8, 9])
let map = new Map([
    [1, 'one'],
    [2, 'two'],
    [3, 'three']
])
let setArr = [...set]
let mapArr = [...map]
console.log(setArr)
console.log(mapArr)

数组实例的includes().
Array.prototype.includes方法返回一个布尔值，表示某个数组是否包含给定的值，与字符串的includes方法类似。

在该方法之前，通常使用数组的indexOf方法检查是否包含某个值。indexOf方法有两个缺点：

一是不够语义化，起含义是找到参数值的第一次出现的位置，所以要比较是否不等于-1，表达起来不够直观；二是，其内部使用严格相等运算符（===）会对NaN产生误判。

includes使用的是不一样的判断算法，就没有这个问题。