[js] 第15天 写一个数组去重的方法（支持多维数组）

[haizhilin2013]

第15天 写一个数组去重的方法（支持多维数组）

[linghucq1]

function flat(arr, target) {
  arr.forEach(item => {
    if (Array.isArray(item)) {
      flat(item, target)
    } else {
      target.push(item)
    }
  })
}

function flatArr(arr) {
  let result = []
  
  flat(arr, result)
  
  return result
}

function uniqueArr(arr) {
  return [...new Set(flatArr(arr))]
}

const result = uniqueArr([1, 2, 3, 4, [3, 4, [4, 6]]])

console.log(result) // 1,2,3,4,6

---

有一个兼容性不太好的写法：

function uniqueArr(arr) {
  return [...new Set(arr.flat(Infinity))]
}

参考：Array.prototype.flat

[myprelude]

• 一维

new set(...arr)

• 二维

arr.reduce((a,b)=>{
return new set(...a.concat(b))
},[])

[think2011]

说个兼容性比较好的，当然最简单的方式还是基于 new Set

[1,2,3,4,4,5,5,2].filter((item, index, arr) => arr.indexOf(item) === index)

[Damon99999]

// 将数组降维
function resetArray(arr, newArr){
    arr.forEach(item => {
        if (toString.call(item) === "[object Array]") {
		resetArray(item, newArr);
        } else {
		newArr.push(item);
	}
    })
}
// 将数组去重
function uniArr(arr) {
    var newArr = [];
    resetArray(arr, newArr);
    console.log([...new Set(newArr)]);
}
arr = [1, 2, 3, [1, 2, [3, 4]], [1]]
uniArr(arr);

[AricZhu]

/* 利用Set来去重 利用递归来处理多维情况 */

function getNoRepeatArr (arr, set) {

if (Array.isArray(arr)) {
	arr.forEach(item => getNoRepeatArr(item, set));
} else {
	set.add(arr);
}

}

[Konata9]

// ES6
const uniqueArr = (arr) => [
  ...new Set(
    arr.reduce(
      (prev, cur) =>
        Array.isArray(cur) ? prev.concat(...uniqueArr(cur)) : prev.concat(cur),
      []
    )
  )
];

console.log(uniqueArr([1, 2, 3, 4, 4, 3, 2, 1, 1, 2, 3, 4, 4, 3, 2, 1, 5, 6]));
console.log(uniqueArr([1, 2, 3, 4, 4, 3, 2, 1, [1, 2, 3, [4, 3, 2, 1]]]));
console.log(
  uniqueArr([
    1,
    2,
    3,
    [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3]]]]]]
  ])
);

// ES5
const uniqueArrES5 = (arr) => {
  const unique = [];
  const flattedArr = arr.reduce(
    (prev, cur) =>
      Array.isArray(cur)
        ? prev.concat(uniqueArrES5(cur))
        : prev.concat(cur),
    []
  );

  while (flattedArr.length > 0) {
    const head = flattedArr.shift();
    if (flattedArr.indexOf(head) < 0) {
      unique.push(head);
    }
  }
  return unique;
};

console.log(
  uniqueArrES5([1, 2, 3, 4, 4, 3, 2, 1, 1, 2, 3, 4, 4, 3, 2, 1, 5, 6])
);
console.log(uniqueArrES5([1, 2, 3, 4, 4, 3, 2, 1, [1, 2, 3, [4, 3, 2, 1]]]));
console.log(
  uniqueArrES5([
    1,
    2,
    3,
    [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3]]]]]]
  ])
);

[shufangyi]

const flatArray = array =>
  array.reduce(
    (pre, item) =>
      Array.isArray(item) ? [...pre, ...flatArray(item)] : [...pre, item],
    []
  )

const uniqueArray = (array, fn = (a, b) => a === b) =>
  array.filter(
    (item, index) => array.findIndex(value => fn(value, item)) === index
  )

const test = [
  { name: '2' },
  { name: '1' },
  2,
  3,
  [4, 5, [6, 7, [8, { name: '2' }, 4, 9, [10, 9]]]]
]

console.log(uniqueArray(flatArray(test))) // [ { name: '2' }, { name: '1' }, 2, 3, 4, 5, 6, 7, 8, { name: '2' }, 9, 10 ]

console.log( // [ { name: '2' }, { name: '1' }, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] 
  uniqueArray(flatArray(test), (a, b) => {
    return a === b || (a.name && b.name && a.name === b.name)
  })
)

[wyx2014]

const multiLevel2OneLevel = function (arr) {
   const dedupliArr = arr.reduce(function (prev, cur) {
       return Array.isArray(cur)? prev.concat(multiLevel2OneLevel(cur)):prev.concat(cur);
   },[])
   return dedupliArr;
}
const deduplicatArr = function(arr) {
   return Array.from(new Set(arr));
}
const deduplicatArrTwo = function(arr) {
   const unique = [];
   while(arr.length > 0){
       var headVal = arr.shift();
       if(arr.indexOf(headVal) === -1) {
          unique.push(headVal);
      }
   }
   return unique;
}
console.log(deduplicatArr(multiLevel2OneLevel([11,233,45,11,[22,3,,233,45,[2,34,55,67,45]]])));
console.log(deduplicatArrTwo(multiLevel2OneLevel([11,233,45,11,[22,3,,233,45,[2,34,55,67,45]]])));

[Vi-jay]

function deWeighting(arr = []) {
  let targetIndex = null;
  arr = arr.slice();
  while ((targetIndex = arr.findIndex(Array.isArray)) > -1) {
    arr.splice(targetIndex, 1, ...arr[targetIndex].flat());
  }
  return [...new Set(arr)]
}

[AchillesV]

const uniqueArr = (arr) => {
  let result = []
  for (let i=0; i<arr.length; i++) {      
    arr[i] instanceof Array 
    ? result.push(removeArr(arr[i])) 
    : result.indexOf(arr[i]) === -1 ? result.push(arr[i]) : null;
  }
  return result
}

[nnnnnnnnnni]

function distinct(a){ return Array.from(new Set(a)) }

[15190408121]

讲个比较笨的 var arrys = [] function arrs(arr) { // 先把所有的提出来 for (var i = 0; i < arr.length; i++) { if (Array.isArray(arr[i]) === true) { arrs(arr[i]) } else { arrys.push(arr[i]) } } } function Arrys(arr, arrys) { // 之后去重 arrs(arr) return [...new Set(arrys)] } Arrys([1, 2, 3, 4, 4, 3, 2, 1, [1, 2, 3, 5, [5, 4, 3, 2, 1]]], arrys)

[wsypower]

function deepFlatten(arr) {
  return [
    ...new Set(
      [].concat(...arr.map(v => (Array.isArray(v) ? deepFlatten(v) : v)))
    )
  ];
}
const result = deepFlatten([1, 2, 3, 4, [3, 4, [4, 6]]]);
console.log(result); // 1,2,3,4,6

[Zhou-Bill]

function dup(list) {
    let arr = flatten(list);
    let res = simple(arr);
    return res;
}
//先把他扁平化
function flatten(list) {
    const res = list.reduce((prev, current) => {
        let temp = current instanceof Array ? flatten(current) : current;
        return prev = prev.concat(temp);
    }, []);
    return res;
}

function simple(arr) {
    let res = new Set(arr);
    return [...res];
}
dup([1,2,3, [1,3,4]]);

[fanqingyun]

function rid(arr){ arr = arr.map(item=>{ if (item instanceof Array){ return rid(item) } else{ return item } }) return [...new Set(arr)] }

[ZindexYG]

function flat(arr, target) {
  arr.forEach(item => {
    if (Array.isArray(item)) {
      flat(item, target)
    } else {
      target.push(item)
    }
  })
  return target
}

function uniqueArr(arr) {
  let result = []
  let resultFilter = flat(arr, result)
  return [...new Set(resultFilter)]
}

// let resultArr = uniqueArr([1, 2, 3, 4, [3, 4, [4, 6]]])

// console.log(resultArr) // 1,2,3,4,6

[Tseian]

function unique(arr, index) {
    if (index == arr.length) return arr;
    let next = index + 1;
    if (Array.isArray(arr[index])) {
        arr[index] = unique(arr[index], 0);
        return unique(arr, next);
    } else {
        let hasSame = -1;
        for (let i = 0; i < index; i++) {
            if (arr[i] == arr[index]) {
                hasSame = i;
                break;
            }
        }
        if (hasSame > -1) { //删除
            arr.splice(hasSame, 1)
            return unique(arr, index);
        } else {
            return unique(arr, next);
        }
    }
}
const result = unique([1, 2, 2, 3, 4, [3, 3, 4, 4, [4, 6]]], 0)

console.log(result) // [ 1, 2, 3, 4, [ 3, 4, [ 4, 6 ] ] ]

[diandianzd]

const uniqueArr = (arr) => [...new Set(arr.toString().split(','))]


console.log(uniqueArr([1, 2, 3, 4, 4, 3, 2, 1, 1, 2, 3, 4, 4, 3, 2, 1, 5, 6]));
console.log(uniqueArr([1, 2, 3, 4, 4, 3, 2, 1, [1, 2, 3, [4, 3, 2, 1]]]));
console.log(
  uniqueArr([
    1,
    2,
    3,
    [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3]]]]]]
  ])
);

// [ '1', '2', '3', '4', '5', '6' ]
// [ '1', '2', '3', '4' ]
// [ '1', '2', '3' ]

[smeltH]

function toSame(arr){
    const newArr = arr.toString().split(',');
    return [...new Set(newArr)];
}

[0x3c]

/**
 * 元素为非数组则直接对数组去重
 * 元素为数组则对元素去重
 * @param {array} arr
 * @return {array}
 */
function uniqueArr(arr) {
  for (let i = 0; i < arr.length; i++) {
    if (Array.isArray(arr[i])) {
      arr[i] = uniqueArr(arr[i]);
    }
  }
  return Array.from(new Set(arr));
}

[xiaobaichiliangpi]

function flatAndUnique(target) {
    return [...new Set(target.join(',').split(','))]
}
const target = [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3]]]]]]
flatAndUnique(target) // [1,2,3]

[laixihong]

let newArr = arr.toString().split();
Array.from(new Set(newArr))

[YeChang]

//第15天 写一个数组去重的方法（支持多维数组）

function flat(arr, result) {
  arr.map(item => {
    if (Array.isArray(item)) {
      flat(item, result);
    } else {
      result.push(item);
    }
  });
}

function flatArr(arr) {
  let result = [];

  flat(arr, result);

  return result;
}

function uniqueArr(arr) {
  return Array.from(new Set(flatArr(arr)));
}

var arr = [1, 2, [2, 3, [3, 4, 5]], 5, 5];

// console.log(uniqueArr(arr));
console.log(uniqueArr(arr));

[YeChang]

//另一个flat
function flat1(arr) {
  var result = [];
  arr
    .toString()
    .split(",")
    .map(item => {
      result.push(Number(item));
    });
  return result;
}

var arr = [1, 2, [2, 3, [3, 4, 5]], 5, 5];

// console.log(uniqueArr(arr));
console.log(flat1(arr));

[kruzabc]

1,首先是展平多维数组。 利用reduce+递归来展平多维数组。

 function flat(arr) {
     return arr.reduce(function (prev, curr) {
         return Array.isArray(curr) ? prev.concat(flat(curr)) : prev.concat(curr)
     },[]);
}

2.然后就是数组去重 数组去重就是可以用new Set的方式， 当然也有很多种其他方式。 合起来写就是

 function distinct(arr) {
    return [...new Set(flat(arr))]
}

[susanforme]

应该还有很大的改进空间

var ary=[1,1,2,2,3,['a','a','c',['q','q']]];
function bar(ary){
  for(let i=0;i<ary.length;i++){
    if(Array.isArray(ary[i])){
      bar(ary[i]);
    }else{
      for(let j=0;j<ary.length;j++){
        if(ary[i]===ary[j]&&i!=j){
          ary.splice(i,1);    
        }
      }
    } 
  }
}

[276378532]

Array.from(new Set(arr.flat(Infinity))).sort((a,b)=>a-b)
数组扁平化去重排序

[rennzhang]

function distinct(arr) {
  let result = [];
  let obj = {};
  for (let i of arr) {
    if (i instanceof Array) {
      result.push(distinct(i));
    } else if (!obj[i]) {
      result.push(i);
      obj[i] = 1;
    }
  }
  return result;
}
console.log(distinct(arr));

[larry0442]

降维+去重

const flatten = (arr) => {
    const res = [ ];
    arr.forEach(item=>{
        Array.isArray(item) ? res.push.apply(res, flatten(item)) : res.push(item);
    })
   return res;
}
const distint = (arr) =>  {
    return [...new set(arr)]
}

[qiqingfu]

  const isArray = arr => Array.isArray(arr);

  const removeDuplicates = function (array) {
    if (!isArray(array)) {
      throw new Error('传递的不是数组')
    }
    return core(array);
  };

  function core(array) {
    if (!isArray(array)) {
      return array;
    }
    const noDups = [...new Set(array)];
    for (let i = 0; i < noDups.length; i++) {
      noDups[i] = core(noDups[i])
    }

    return noDups;
  }