多维数组转换为一维数组再去重

111 阅读1分钟

数组和字符串的相互转换

字符串转数组

    var str =  "helloworld";
    console.log(str.split('')); 
    //["h", "e", "l", "l", "o", "w", "o", "r", "l", "d"]

数组转字符串

    var arr = [0,1,2,3,4];
    console.log(arr.join("-")); //"0-1-2-3-4" 

split() 将字符串按某个字符切割成若干个字符串,并以数组形式返回,

一维数组去重的方式

第一种:最简单的数组去重

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

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

第二种:利用对象的属性不能相同的特点进行去重

1.创建一个新的数组存放结果

2.创建一个空对象

3.for循环时,每次取出一个元素与对象进行对比,如果这个元素不重复,则把它存放到结果数组中,同时把这个元素的内容作为对象的一个属性,并赋值为1,存入到第2步建立的对象中。

function unique(arr){
    var res = [];
    var obj = {};
    for(var i=0; i<arr.length; i++){
       if( !obj[arr[i]] ){
            obj[arr[i]] = 1;
            res.push(arr[i]);
        }
    } 
 return res;
}
var arr = [1,2,2,3,5,3,6,5];
var res = unique(arr)
console.log(res );

第三种:ES6的set方法

function unique(arr){
 //Set数据结构,它类似于数组,其成员的值都是唯一的
 return Array.from(new Set(arr)); // 利用Array.from将Set结构转换成数组
}

var arr = [1,2,2,3,5,3,6,5];
[...new Set(arr)];  // [1, 2, 3, 5, 6]
Array.from(new Set(arr)); // [1, 2, 3, 5, 6]

[...new Set('ababbc')].join(''); // "abc" 字符串去重
var res = unique(arr)
console.log(res ); // [1, 2, 3, 5, 6]

多维数组转一维数组,然后去重

第一种:join加split

join返回一串字符串

var arr=[[1,2,3],[3,4,5],[6],[6,8]];
var arrString = arr.join(",");
console.log(typeof arrString); 'string'
console.log(arrString); // 1,2,3,3,4,5,6,6,8
var arr1 = arrString.split(",");
console.log(arr1); // ['1', '2', '3', '3', '4', '5', '6', '6', '8']
var result = [];
for(var i=0;i<arr1.length;i++){    
    if(result.indexOf(arr1[i]) == -1){        
        result.push(arr1[i]);    
    }
}
console.log("采用join和split将多维数组转化为一维数组再去重");
console.log(result);

第二种:toString加split,空字符串加split

var test2 = [[1,2,3],[3,4,[7,9,8]],[6],[6,8]];
console.log("采用toString和split将多维数组转化为一维数组再去重");
console.log(test2.toString().split(',')); // ["1", "2", "3", "4", "7", "9", "8", "6"]

console.log("采用拼接空字符串转化为一维数组");
console.log((test2 + "").split(',')); // 1,2,3,3,4,7,9,8,6,6,8

第三种:递归

let arr = [[1,2,3],[3,4,[7,9,8]],[6],[6,8]];
let newArr = []; // 存放转化后的一维数组
function arrConversion (arr) {    
    for (let i = 0; i < arr.length; i++) {       
        // Object.prototype.toString.call(arr[i]) === "[object Array]" 
        if (Array.isArray(arr[i])) {            
            arrConversion(arr[i])        
        } else {            
            newArr.push(arr[i])        
        }    
    }
}
arrConversion(arr);
console.log(newArr); 
// 输出为:["1", "2", "3", "3", "4", "7", "9", "8", "6", "6", "8"]

// 去重
uniq(newArr)

第四种:正则

ary = str.replace(/(\[\]))/g, '').split(',');

第五种:reduce加concat,可以指定嵌套深度

var test2 = [[1,2,3],[3,4,[7,9,8]],[6],[6,8]];function flat(arr, n) {    
    return arr.reduce(function (acc, cur) {        
        return acc.concat(Array.isArray(cur) ? flat(cur, n-1) : cur)    
}, [])}
console.log(flat(test2, 2));

第l六种:使用生成器(generator函数)功能(MDN)

function* flatten(array, depth) {
  if (depth === undefined) {
    depth = 1;
  }

  for (const item of array) {
    if (Array.isArray(item) && depth > 0) {
      yield* flatten(item, depth - 1);
    } else {
      yield item;
    }
  }
}

const arr = [1, 2, [3, 4, [5, 6]]];
const flattened = [...flatten(arr, Infinity)];
// [1, 2, 3, 4, 5, 6]