数组去重

数组中包含数组

输入：[1, 2, 3, 1, '1', [1, 2, 1]]

输出： [1,2,3, '1', [1, 2]]

修正版本

function unique(nums){
    let res = []
    for(let num of nums){
        if(Array.isArray(num)){
            res.push(unique(num))
        }else{
            if(!res.includes(num)){
                res.push(num)
            }
        }
    }
    return res // 好像忘记写这里的返回了
}

使用了set来处理别的数组，不太通用了

function unique(nums){
	let result = []
	nums.forEach((item) => {
		if(Array.isArray(item)) {
			result.push([...new Set(item)])
		}else{
			if(!result.includes(item)) result.push(item)
		}
	})
	return result
}

基础数组去重

filter去重

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

新数组

const uniqueArr = [] // 新数组
arr.forEach(item => {
		//新数组中没有的都放入
    if(uniqueArr.indexOf(item) === -1) uniqueArr.push(item)
})

reduce

[1,2,1,2,3,3].reduce((acc, cur) => {
	if(acc.indexOf(cur) === -1){
		acc.push(cur)
	}
	return acc
}, [])

Set去重

Array.from(new Set([1,1,2,3,3]))

Map去重

// map中已经有的直接返回false，没有的利用set方法返回的是map本身 ，可以被转为true的特性
function unique(arr){
	const m = new Map()
	return arr.filter(item => !m.has(item) && m.set(item, 1))
}

利用map的key来记录

function unique(arr){
	const result = []
	const m = new Map()
	arr.forEach((item) => {
		if(!m.has(item)){
			m.set(item, 1)
			result.push(item)
		}
	})
	return result
}

排序相邻

先排序之后利用后者如果不等于前者，就放入新数组中

const sortArr = arr.sort((value1, value2) => value1-value2)
const uniqueArr = []
for(let i = 1; i <= sortArr.length; i++){
	if(sortArr[i] !== sortArr[i-1]) uniqueArr.push(sortArr[i-1])
}

Object对象数组去重

去除name相同的对象

let arr = [
	{key: 1, name: 'aa'},
	{key: 2, name: 'aa'},
	{key: 3, name: 'bb'}
]

reduce去重

function uniqueObj(arr){
	// 备忘录来记录key为name
	const obj = {}
	return arr.reduce((acc, cur) => {
		// 如果不存在，则用收集器收集起来
		if(!obj[cur.name]){
			acc.push(cur)
			obj[cur.name] = true
		}
		return acc
	}, [])
}

Map去重

基本道理和上面用对象key唯一性一样样

function uniqueObj(arr){
	const m = new Map()
	arr.forEach(item => {
		if(!m.has(item.name)){
			m.set(item.name, item)
		}
	})
	return [...m.values()]
}

双循环去重

function uniqueObj(arr){
	const result = []
	// 第一层循环正常遍历
	arr.forEach(item => {
		// 如果结果数组中不存在相同的name就push进去
		const hasPush = result.some(x => x.name === item.name)
		if(!hasPush) result.push(item)
	})
	return result
}