JS数组操作（扁平化去重排序交集并集差集）

Posted 2021-06-04 超帅的轻省回望

一、数组扁平化

有数组：let arr = [[2, 3, 1],[4, 3, 6, 5],[6, 2, 4, 9, [4, 11, 12, [12, 13, [10], 15]]], 20]
1. reduce

//若值为数组则递归遍历，否则concat
function flatten(arr) {  
    return arr.reduce((result, item)=> {
        return result.concat(Array.isArray(item) ? flatten(item) : item);
    }, []);
}
//reduce是数组的一种方法，它接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。
//reduce包含两个参数：回调函数，传给total的初始值

// 求数组的各项值相加的和：
arr.reduce((total, item)=> {  // total为之前的计算结果，item为数组的各项值
    return total + item;
}, 0);

2.toString & split

//调用数组的toString方法，将数组变为字符串然后再用split分割还原为数组
function flatten(arr) {
    return arr.toString().split(\',\').map(function(item) {
        return Number(item);
    })
}
//因为split分割后形成的数组的每一项值为字符串，所以需要用一个map方法遍历数组将其每一项转换为数值型

3.join & split

//和上面的toString一样，join也可以将数组转换为字符串
function flatten(arr) {
    return arr.join(\',\').split(\',\').map(function(item) {
        return parseInt(item);
    })
}

4. 递归

function flatten(arr) {
    var res = [];
    arr.map(item => {
        if(Array.isArray(item)) {
            res = res.concat(flatten(item));
        } else {
            res.push(item);
        }
    });
    return res;
}

5.扩展运算符

//es6的扩展运算符能将二维数组变为一维
[].concat(...[1, 2, 3, [4, 5]]);  // [1, 2, 3, 4, 5]
//根据这个结果我们可以做一个遍历，若arr中含有数组则使用一次扩展运算符，直至没有为止。
function flatten(arr) {
    while(arr.some(item=>Array.isArray(item))) {
        arr = [].concat(...arr);
    }
    return arr;
}

 

二、去重

1、去重方法一(Set)

Array.from方法用于将两类对象转为真正的数组：类似数组的对象（array-like object）和可遍历（iterable）的对象（包括ES6新增的数据结构Set和Map）。ES6 提供了新的数据结构 Set。它类似于数组，但是成员的值都是唯一的，没有重复的值；

var duplicate = Array.from(new Set(newArr1))

2、去重方法二(reduce)

//通过数组reduce方法，利用indexOf判断上一次回调返回数组a中是否包含当前元素b的索引，如果不存在，则把b元素加入a数组，否则直接返回a。
var duplicate1 = newArr1.reduce((a, b) => {
    if(a.indexOf(b) === -1) {
        a.push(b)
    }
    return a
}, [])

3、去重方法三(数组下标去重法)

//通过数组的过滤filter方法，利用indexOf获取当前元素ele在被过滤数组farr中的第一个索引值，如果值与当前索引值index相等则返回，如果不相等则过滤。
var duplicate2 = newArr1.filter((ele, index, farr) => {
    return farr.indexOf(ele) === index
})

4、去重方法四(遍历数组)

//遍历数组，建立新duplicate3 数组，利用indexOf判断元素是否存在于duplicate3 新数组中，不存在则push到duplicate3 新数组。
var duplicate3 = []
for(var i = 0; i < newArr1.length; i++) {
    if(duplicate3.indexOf(newArr1[i]) === -1) {
        duplicate3.push(newArr1[i])
    }
}

5、去重方法五(排序后相邻去重法)

//给传入数组排序，排序后相同值相邻，然后遍历时新数组只加入不与前一值重复的值。
function unique3(arr) {
    arr.sort();
    var newArr = [arr[0]];
    for(var i = 1, len = arr.length; i < len; i++) {
        if(arr[i] !== newArr[newArr.length - 1]) {
            newArr.push(arr[i]);
        }
    }
    return newArr;
}
var duplicate4 = unique3(newArr1)

 

三、数组排序

有数组：let initarr=[12, 13, 2, 5, 4, 8, 6, 9, 11, 15, 1, 3, 10, 14, 16]

1、sort排序

function arrSort(arr) {
   return arr.sort(function(a, b) {
       return a - b
   })
}
var sort = arrSort(initarr)

2、冒泡排序

function bubbleSort(arr) {
    var len=arr.length
       for(var i = len-1; i > 0; i--) {
          for(var j = 0; j < i; j++) {
             if(arr[j] > arr[j+1]) {
             var tmp = arr[j]
             arr[j] = arr[j + 1]
             arr[j + 1]= tmp
             }  
          }
       }
       return arr
    }
var sort1 = bubbleSort(initarr)

3、插入排序

function insertSort(arr) {
    // 假设第一个元素已经排好序
    for (let i = 1; i < arr.length; i++) {
        if (arr[i] < arr[i - 1]) {
            // 取出无序序列中需要插入的第i个元素
            var temp = arr[i];
            // 定义有序中的最后一个位置
            var j = i - 1;
            arr[i] = arr[j];
            // 根据序列最后一位，不断循环比较，找到插入的位置
            while(j >= 0 && temp < arr[j]){
                arr[ j+1 ] = arr[j];
                j--;
            };
            //插入
            arr[ j+1 ] = temp;
        }
    }
}

var sort2 = insertSort(initarr)

4、希尔排序

function shellSort(arr) {
    var len = arr.length;
    // 定义间隔区间
    var fraction = Math.floor(len / 2);
    // fraction = Math.floor(fraction / 2) => 循环中不断切割区间
    for (fraction; fraction > 0; fraction = Math.floor(fraction / 2)) {
        // 以间隔值开始遍历
        for (var i = fraction; i < len; i++) {
            // 如果前面一个大于后面一个
            for (var j = i - fraction; j >= 0 && arr[j] > arr[fraction + j]; j -= fraction) {
                var temp = arr[j];
                arr[j] = arr[fraction + j]; // 后移
                arr[fraction + j] = temp; // 填补
            }
        }
    }
}
var sort3 = shellSort(initarr)

 

四、交集、并集、差集

现有两数组a = [1, 2, 3]，b = [2, 4, 5]

1、ES7的方式

　　// 并集
　　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]

2、ES6

    let aSet = new Set(a)
    let bSet = new Set(b)
    
    // 并集
    let union = Array.from(new Set(a.concat(b))) // [1,2,3,4,5]
    
    // 交集
    let intersection = Array.from(new Set(a.filter(v => bSet.has(v))))
    
    // 差集
    let differenceNew = Array.from(new Set(a.concat(b).filter(v => aSet.has(v) && !bSet.has(v))))

3、ES5

    // 并集
    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]

 

考虑有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