数组扁平化以及数组去重

最近在复习数组，就对数组去重以及扁平化做了一些整理，在这里分享给大家！

数组扁平化

概念： 数组扁平化是指将一个多维数组变为一维数组

我在这里给大家总结了五种数组扁平化方式，通俗来说，数组扁平化的核心就是遍历数组arr，若arr[i]为数组则递归遍历，直至arr[i]不为数组然后与之前的结果concat。所以我们围绕核心来写代码。

1.普通递归

let result = []
let flatten = function (arr) {
     
  for (let i = 0; i < arr.length; i++) {
     
    let item = arr[i]
    if (Array.isArray(arr[i])) {
     
      flatten(item)
    } else {
     
      result.push(item)
    }
  }
  return result
}

let arr = [1, 2, [3, 4], [5, [6, 7]]]
console.log(flatten(arr))

2.调用 ES6 中的 flat 方法

ary = arr.flat(Infinity)

console.log([1, [2, 3, [4, 5, [6, 7]]]].flat(Infinity))

3.扩展运算符

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;
}

4.toString & split

调用数组的toString方法，将数组变为字符串然后再用split分割还原为数组

function flatten(arr) {
     
    return arr.toString().split(',').map(function(item) {
     
        return Number(item);
    })
} 

因为split分割后形成的数组的每一项值为字符串，所以需要用一个map方法遍历数组将其每一项转换为数值型

5.利用 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);

6. join & split

和上面的toString一样，join也可以将数组转换为字符串

function flatten(arr) {
     
    return arr.join(',').split(',').map(function(item) {
     
        return parseInt(item);
    })
}

数组去重

1.indexOf去重

新建一新数组，遍历传入数组，值不在新数组就push进该新数组中
（【注】：IE8以下不支持数组的indexOf方法）

function lyf(arr){
     
    var temp = []; //一个新的临时数组
    for(var i = 0; i < arr.length; i++){
     
        if(temp.indexOf(arr[i]) == -1){
     
            temp.push(arr[i]);
        }
    }
    return temp;
}

var aa = [1,2,2,4,9,6,7,5,2,3,5,6,5];
console.log(lyf(aa));

2、排序相邻排除法

先将原数组排序，在与相邻的进行比较，如果不同则存入新数组。

function lyf(arr) {
     
  var formArr = arr.sort()
  var newArr = [formArr[0]]
  for (let i = 1; i < formArr.length; i++) {
     
    if (formArr[i] !== formArr[i - 1]) {
     
      newArr.push(formArr[i])
    }
  }
  return newArr
}
console.log(lyf([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]))

3.includes

includes() 方法用于判断字符串是否包含指定的子字符串。
如果找到匹配的字符串则返回 true，否则返回 false。那么我们利用这个点就可以去重啦

function lyf(arr) {
     
  var newArr = []
  for (var i = 0; i < arr.length; i++) {
     
    if (!newArr.includes(arr[i])) {
     
      newArr.push(arr[i])
    }
  }
  return newArr
}
console.log(lyf([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]))

4.利用 ES6 的 set 方法

function lyf(arr) {
     
  return Array.from(new Set(arr)) // 利用Array.from将Set结构转换成数组
}
console.log(lyf([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]))

5.利用数组原型对象上的 filter 和 includes 方法

filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素

function unique(arr) {
     
  var newArr = []
  newArr = arr.filter(function (item) {
     
    return newArr.includes(item) ? '' : newArr.push(item)
  })
  return newArr
}
console.log(unique([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]))

6.优化遍历数组法

实现思路：获取没重复的最右一值放入新数组。（检测到有重复值时终止当前循环同时进入顶层循环的下一轮判断）

function lyf(array){
     
    var temp = [];
    var index = [];
    var l = array.length;
    for(var i = 0; i < l; i++) {
     
        for(var j = i + 1; j < l; j++){
     
            if (array[i] === array[j]){
     
                i++;
                j = i;
            }
        }
        temp.push(array[i]);
        index.push(i);
    }
    console.log(index);
    return temp;
}

var aa = [1,2,2,3,5,3,6,5];
console.log(lyf(aa));