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

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
}

shenger9

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]]);

27 remaining items

codeyourwayup

先把数组拍平

const a=[1, 2, 3, 4, [3, 4, [4, 6]]];
const re=[];
function isFlat(arr){
  let flat=true;
  for(let a of arr){
    if(Array.isArray(a)){
     flat=false;
    }
  }
  return flat;
}
function flat(arr){
//if this array is flat, just push it
if(isFlat(arr)){
  re.push(...arr);
  return;
}
//if not flat, check each ele, if flat push, else recursive
for(let a of arr){
  if( !Array.isArray(a)){
   re.push(a);
  }else{
   flat(a);    
  }
}
}
//start 
flat(a);
console.log(re)

HNHED

amikly

ES5

//ES5
function uniqueArr(arr) {
    const result = [];
    const dimenArr = arr.reduce(
        (prev, curr) =>
        Array.isArray(curr) ? prev.concat(uniqueArr(curr)) : prev.concat(curr),
        []
    );
    while (dimenArr.length) {
        let element = dimenArr.shift();
        if (!dimenArr.includes(element)) {
            result.push(element);
        }
    }
    return result;
}
console.log(uniqueArr([1, 2, 3, 4, [3, 4, [4, 6]]]));

ES6

// ES6
function uniqueArr(arr) {
    [
        new Set(
            arr.reduce(
                (prev, curr) =>
                Array.isArray(cur)
                ? prev.concat(...uniqueArr(curr))
                : prev.concat(cur),
                []
            )
        ),
    ];
}
console.log(uniqueArr([1, 2, 3, 4, [3, 4, [4, 6]]]));

github-cxtan

yxllovewq

const arr2set = (arr = []) => {
  let newArr = [];
  for (let value of arr) {
    if (typeof value === 'number') {
      if (newArr.every(v => v !== value)) newArr.push(value);
    }
    else newArr.push(arr2set(value));
  }
  return newArr;
}

storm-cao

            const list = [];
	const arrayHandle = (array) => {
		array.map(item => {
			if (Array.isArray(item)) {
				arrayHandle(item);
			} else {
				list.push(item)
			}
		})

		return [...new Set(list)];
	}

wind8866

看别人的结果都是一维数组，我这个去重并且保留原数组的格式（空数组去除）

const unique = (arr) => {
  const set = new Set()
  const loop = (arr) => {
    return arr.reduce((result, current) => {
      if (Array.isArray(current)) {
        const arrTemp = loop(current)
        if (arrTemp.length > 0) result.push(arrTemp)
        return result
      }
      if (set.has(current)) return result
      set.add(current)
      result.push(current)
      return result
    }, [])
  }
  return loop(arr)
}
unique([1,2,3,[1, 4, [2]],4,5], 7, 8, 7)

vesere

var arr = [
[11,1,2,2],
[3,4,5,5],
[6,7,8,9,10,
[11,12,
[12,12,
[13]
]
]
]
]

// 1、数组扁平化
// 2、去重
// 3、排序

// 方法一：递归要使用function因为this指向不然箭头函数指向window
Array.prototype.flat = function(){
// 首先将数组遍历处理
const result = this.map(item => {
if(Array.isArray(item)) {
console.log(item);
console.log('-----------------------------------------------------------------------------------');
return item.flat()
}
return [item]
});
return [].concat(...result)
}
console.log('-----------------------------------------------------------------------------------');
console.log(arr.flat());

const arr1 = [
1, 2, 2, 3, 4, 5,
5, 6, 7, 8, 9, 11,
12, 12, 12, 13
]
const newArr = new Set(arr1)
console.log(newArr); // 是一个对象类型所以需要将其转化为数组类型
console.log(typeof(newArr));
console.log(newArr.has(9));
console.log([...newArr]);

// 去重操作
Array.prototype.uniquee = function(){
return [...new Set(this)]
}

// 定义排序的顺序
const sortfn = (a,b)=>{
return a - b
}

console.log('------------------------------------------------------------------------------------------------');

const newArray = arr.flat().uniquee().sort(sortfn)

console.log(newArray);

xiaoqiangz

// 写一个数组去重的方法支持多维数组
var arr = [1, 2, [2, 3, [3, 4, 5]], 5, 5];
// 1，升序且去重
console.log(Array.from(new Set(arr.flat(Infinity))).sort((a,b) => a - b))
// 2. reduce
function flat(arr) {
return arr.reduce((prev, cur) => {
return Array.isArray(cur) ? prev.concat(flat(cur)) : prev.concat(cur)
}, [])
}
console.log(Array.from(new Set(flat(arr))))
// 3 递归
function flatArr(arr, result) {
arr.forEach(item => {
if (Array.isArray(item)) {
flatArr(item, result)
} else {
result.push(item)
}
})
return result
}
console.log([...new Set(flatArr(arr, []))])

wenxd

  function removeDuplicates(arr) {
    let resArr = []
    arr.map((item) => {
      if (Array.isArray(item)) {
        resArr.push(removeDuplicates(item))
      } else {
        if (!resArr.includes(item)) {
          resArr.push(item)
        }
      }
    })
    return resArr
  }
  let res = removeDuplicates([1,1, 3, 4, 6, 6, 4, 5, 3, [2, 3, 4, 2, 3, 4, 2, 3, 4, [1,1,2,2]]])
  console.log(res)

xiaoxiaozhiya

都要用到ES6的Set对象，保存唯一的值

一维数组
var target=Array.from(new Set(arr))

多维数组
先降维度，再使用Set方法

Sobrium

function flat(arr, newArr){
arr.forEach(item => {
if({}.toString.call(item) === '[object Array]'){
flat(item, newArr);
}else{
if(newArr.indexOf(item) === -1){
newArr.push(item);
}
}
})
}

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

console.log(flatArr([1,2,3,4,[1,2,3],4,[a,b,5,[4,5,6],[1,2]]]))

Rednaxela-LinYi

。。。人家让你们去重，谁让你们降维了，题目要求难道不是返回一个和原数组结构相同的，去重后的数组吗？
function deSameElement(arr, resMap = {}) {
return arr.reduce((acc, cur) => {
let res = null;
if (Array.isArray(cur)) {
res = deSameElement(cur, resMap);
if (Array.isArray(res) && res.length > 0) {
acc.push(res);
}
} else {
if (!resMap[cur]) {
res = cur;
resMap[cur] = true;
acc.push(res);
}
}
return acc;
}, []);
}

let testArr = [
[1, 2, 3, 4, 5, 6],
[2, 5, 7, 9, 4, 3],
10,
5,
8,
[2, 3, 3],
4,
3,
9,
];

console.log(deSameElement(testArr)); // [ [ 1, 2, 3, 4, 5, 6 ], [ 7, 9 ], 10, 8 ]

pengsir120

function arrayFlat(arr) {
return Array.from(new Set(arr.flat(Infinity)))
}

panpanxuebing

// 数组去重
function flat (arr, n = 1) {
  return n > 0 ? arr.reduce((pre, cur) => {
    return pre.concat(Array.isArray(cur) ? flat(cur,  n - 1) : cur)
  }, []) : arr.slice()
}

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

const arr = [1, 2, 3, '', '', 4, [3, 4, [4, 6, [7, 8]]], , ,]
console.log(unique(arr, Infinity)) // [1, 2, 3, '', 4, 6, 7, 8]

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

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

27 remaining items

ES5

ES6

都要用到ES6的Set对象，保存唯一的值

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Participants

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

Description

Activity

linghucq1 commented on May 8, 2019

myprelude commented on Jun 13, 2019

think2011 commented on Jun 17, 2019

Damon99999 commented on Jun 19, 2019

AricZhu commented on Jun 24, 2019

Konata9 commented on Jul 10, 2019

shufangyi commented on Jul 18, 2019

wyx2014 commented on Jul 25, 2019

Vi-jay commented on Jul 26, 2019

AchillesV commented on Jul 29, 2019

shenger9 commented on Aug 22, 2019

15190408121 commented on Aug 25, 2019

wsypower commented on Aug 29, 2019

Zhou-Bill commented on Aug 30, 2019

27 remaining items

codeyourwayup commented on Jul 21, 2021

HNHED commented on Sep 3, 2021

amikly commented on Nov 2, 2021

ES5

ES6

github-cxtan commented on Feb 17, 2022

yxllovewq commented on Mar 8, 2022

storm-cao commented on Mar 11, 2022

wind8866 commented on Mar 25, 2022

vesere commented on May 18, 2022

xiaoqiangz commented on May 25, 2022

wenxd commented on May 27, 2022

xiaoxiaozhiya commented on May 30, 2022

都要用到ES6的Set对象，保存唯一的值

Sobrium commented on Sep 12, 2022

Rednaxela-LinYi commented on Jul 21, 2023

pengsir120 commented on Sep 27, 2024

panpanxuebing commented on Dec 10, 2024

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Participants

Issue actions

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