js数组求并集，交集，差集

素颜马尾好姑娘i 2022-12-30 10:38 191阅读 0赞

## 前言 ##

前几天面试的时候，有一道笔试题是用js求数组的交集，差集和并集，因为之前没有听过这个概念，就空着了，所以今天是想要专门写篇文章来记录一下。

现有两数组a = [1, 2, 3]，b = [2, 4, 5]，求a，b数组的并集，交集和差集。

--------------------

## 基本概念 ##

集合的分类:  
并集：以属于A或属于B的元素为元素的集合成为A与B的并（集） 记作A∪B（或B∪A），读作“A并B”（或“B并A”），即A∪B=\{x|x∈A,或x∈B\}  
交集：以属于A且属于B的元素为元素的集合成为A与B的交（集） 记作A∩B（或B∩A），读作“A交B”（或“B交A”），即A∩B=\{x|x∈A,且x∈B\}  
差集：以属于A而不属于B的元素为元素的集合成为A与B的差（集）记作A-B（或B∩A），读作“A减B”，即A-B=\{x∣x∈A,且x∉B\}

## 方法选择 ##

JS在ES6，ES7之后，新增了一些数组方法，如果能够使用，那是极好的，毕竟自己写封装函数还是比较辛苦的。

### ES7 ###

ES7新增了一个`Array.prototype.includes`的数组方法，用于返回一个数组是否包含指定元素，结合`filter`方法。

> var boolean = array.includes(searchElement\[, fromIndex\])

// 并集
    let union = a.concat(b.filter(v => !a.includes(v))) // [1,2,3,4,5]
    // 交集
    let intersection = a.filter(v => b.includes(v)) // [2]
    // 差集
    let difference = a.concat(b).filter(v => a.includes(v) && !b.includes(v)) // [1,3]

### ES6 ###

ES6中新增的一个`Array.from`方法，用于将类数组对象和可遍历对象转化为数组。只要类数组有`length`长度，基本都可以转化为数组。结合`Set`结构实现数学集求解。

> Array.from(arrayLike\[, mapFn\[, thisArg\]\])

### ES5 ###

ES5可以利用`filter`和`indexOf`进行数学集操作，但是，由于`indexOf`方法中`NaN`永远返回-1，所以需要进行兼容处理。

*  不考虑NaN(数组中不含NaN)

var a = [1,2,3];
        var b = [2,4,5];
     
        // 并集
        var union = a.concat(b.filter(function(v) { 
            return a.indexOf(v) === -1})) // [1,2,3,4,5]
     
        // 交集
        var intersection = a.filter(function(v){  return b.indexOf(v) > -1 }) // [2]
     
        // 差集
        var difference = a.filter(function(v){  return b.indexOf(v) === -1 })// [1,3]
     
        console.log(union)
        console.log(intersection)
        console.log(difference)

*  考虑NaN

var a = [1, 2, 3, NaN];
        var b = [2, 4, 5];
     
        var aHasNaN = a.some(function (v) { 
            return isNaN(v)
        })
        var bHasNaN = b.some(function (v) { 
            return isNaN(v)
        })
     
        // 并集
        var union = a.concat(b.filter(function (v) { 
            return a.indexOf(v) === -1 && !isNaN(v)
        })).concat(!aHasNaN & bHasNaN ? [NaN] : []) // [1,2,3,4,5,NaN]
     
        // 交集
        var intersection = a.filter(function (v) { 
            return b.indexOf(v) > -1
        }).concat(aHasNaN & bHasNaN ? [NaN] : []) // [2]
     
        // 差集
        var difference = a.filter(function (v) { 
            return b.indexOf(v) === -1 && !isNaN(v)
        }).concat(aHasNaN && !bHasNaN ? [NaN] : [])//1,3,NaN
     
        console.log(union)
        console.log(intersection)
        console.log(difference)