JS 实现两个数组的交集，并集，差集和补集前言 1. 什么是交集设有 A, B 两个集合，由所有属于集合 A 且也属于

开始

前言

1. 什么是交集

设有 A, B 两个集合，由所有属于集合 A 且也属于集合 B 的元素所组成的集合，叫做集合 A 与集合 B 的交集

2. 什么是并集

设有 A, B 两个集合，把他们所有的元素合并在一起组成的集合，叫做集合 A 与集合 B 的并集

3. 什么是差集

设有 A, B 两个集合，所有属于 A 且不属于 B 的元素组成的集合叫做集合 A 与集合 B 的差集

4. 什么是补集

设有 A, B 两个集合，集合 A 是集合 B 的一个子集，由集合 B 中所有不属于集合 A 的元素组成的集合，叫做子集 A 在集合 B 中的补集

简单数组交集

1. 方法一使用 filter 和 indexOf

let A = [1, 2, 3, 4]
let B = [2, 3, 4, 5]
let result = A.filter(item => B.indexOf(item) > -1)
console.log(result) // [2, 3, 4]

2. 方法二使用 filter 和 includes

let A = [1, 2, 3, 4]
let B = [2, 3, 4, 5]
let result = A.filter(item => B.includes(item))
console.log(result) // [2, 3, 4]

数组对象交集

使用 filter 和 find

let A = [{id: 1, name: '小明'}, {id: 2, name: '小王'}, {id: 3, name: '小红'}]
let B = [{id: 2, name: '小王'}, {id: 3, name: '小红'}]
let result = A.filter(item => B.find(bItem => item.id == bItem.id))
console.log(result) // [{id: 2, name: '小王'}, {id: 3, name: '小红'}]

简单数组并集

1. 方法一使用 concat, Set 和 Array.from

let A = [1, 2, 3, 4]
let B = [2, 3, 4, 5]
let result = Array.from(new Set(A.concat(B)))
console.log(result) // [1, 2, 3, 4, 5]

2. 方法二使用 concat, filter 和 includes

let A = [1, 2, 3, 4]
let B = [2, 3, 4, 5]
let result = A.concat(B.filter(item => !A.includes(item)))
console.log(result) // [1, 2, 3, 4, 5]

数组对象并集

使用 Map 和 filter

let A = [{id: 1, name: '小明'}, {id: 2, name: '小王'}, {id: 3, name: '小红'}]
let B = [{id: 2, name: '小王'}, {id: 3, name: '小红'}]
let map = new Map()
let result = A.concat(B).filter(item => !map.has(item.id) && map.set(item.id, 1))
console.log(result) // [{id: 1, name: '小明'}, {id: 2, name: '小王'}, {id: 3, name: '小红'}]

简单数组差集

1. 方法一使用 filter 和 includes

let A = [1, 2, 3, 4]
let B = [2, 3, 4, 5]
let result = A.filter(item => !B.includes(item))
console.log(result) // [1]

2. 方法二使用 reduce

let A = [1, 2, 3, 4]
let B = [2, 3, 4, 5]
let result = A.reduce((pre, cur) => {
    if (!B.some(item => item === cur )) {
        pre.push(cur)
    }
    return pre
}, [])
console.log(result) // [1]

数组对象差集

使用 reduce 和 some

let A = [{id: 1, name: '小明'}, {id: 2, name: '小王'}, {id: 3, name: '小红'}]
let B = [{id: 2, name: '小王'}, {id: 3, name: '小红'}]
let result = A.reduce((pre, cur) => {
    if (!B.some(item => item.id === cur.id)) {
        pre.push(cur)
    }
    return pre
}, [])
console.log(result) // [{id: 1, name: '小明'}]

简单数组补集

使用 filter 和 includes

let A = [1, 2, 3, 4]
let B = [1, 2, 3, 4, 5]
let result = B.filter(item => !A.includes(item))
console.log(reuslt) // [5]

数组对象补集

使用filter 和 find

let A = [{id: 1, name: '小明'}, {id: 2, name: '小王'}]
let B = [{id: 1, name: '小明'}, {id: 2, name: '小王'}, {id: 3, name: '小红'}]
let result = B.filter(item => !A.find(aItem => item.id == aItem.id))
console.log(result) // [{id: 3, name: '小红'}]

结束

JS 实现两个数组的交集，并集，差集和补集

前言