python 数组去重_数组去重的方法

定义数组：

var arr = [1,2,3,1,1,1,NaN,NaN,undefined,undefined,null,null,[],[],false, false, 0,0,'1', '2','1',{}, {}]
// 要求返回结果是： [1, 2, 3, NaN, undefined,null,[], false, 0, "1", "2", {}]

ES6 去重

function unique1 (arr){
	return Array.from(new Set(arr))
}
// 无法去掉空对象 {}、空数组 []
// 输出结果是：  [1, 2, 3, NaN, undefined, null, [], [], false, 0, "1", "2", {}, {}]

利用 indexOf 去重

function unique2(arr){
	let result = []
	const len = arr.length
	for(var i=0;i<len;i++){
		if(result.indexOf(arr[i]) === -1){
			result.push(arr[i])
		}
	}
	return result
}
// 无法去掉NaN 、 空对象 以及 空数组
// 输出结果是：[1, 2, 3, NaN, NaN, undefined, null, [], [], false, 0, "1", "2", {}, {}]

利用 map 数据结构去重

创建一个空Map数据结构，遍历需要去重的数组，把数组的每一个元素作为key存到Map中。由于Map中不会出现相同的key值，所以最终得到的就是去重后的结果。

function unique3(arr) {
  let map = new Map();
  let array = new Array();  // 数组用于返回结果
  for (let i = 0; i < arr.length; i++) {
    if(map.has(arr[i])) {  // 如果有该key值
      map.set(arr[i], true); 
    } else { 
      map.set(arr[i], false);   // 如果没有该key值
      array.push(arr[i]);
    }
  } 
  return array ;
}
// 无法去掉空对象 以及 空数组
// 输出结果是：  [1, 2, 3, NaN, undefined, null, [], [], false, 0, "1", "2", {}, {}]

利用 for 循环嵌套，splice 去重

function unique4(arr){
	for(var i=0;i<arr.length;i++){
		for(var j=i+1;j<arr.length;j++){
			if(arr[j] === arr[i]){
				arr.splice(j, 1) // 第一个等于第二个，则删除第二个
				j--
			}
		}
	}
	return arr
}
// 无法去除 NaN，空数组以及空对象
// [1, 2, 3, NaN, NaN, undefined, null, [], [], false, 0, "1", "2", {}, {}]

利用 sort

将原数组排序，循环比较相邻的两个元素是否相等，若不相等则存入一个新数组，返回新数组。

function unique5(arr){
	arr.sort()
	let result = []
	for(var i=0; i<arr.length-1; i++){
		if(arr[i+1] !== arr[i]){
			result.push(arr[i+1])
		}
	}
	return result
}

// 无法去除 NaN 和 空对象
// [[], 0, 1, "1", 2, "2", 3, NaN, NaN, {}, {}, false, null, undefined]

利用 includes

构建一个新数组，循环原数组，使用 includes 判断新数组中是否含有元素，若无，则加入新数组。

function unique6(arr){
	var result = []
	for(var i=0; i<arr.length; i++){
		if(!result.includes(arr[i])){
			result.push(arr[i])
		}
	}
	return result
}
// 无法去除空对象和空数组
// [1, 2, 3, NaN, undefined, null, [], [], false, 0, "1", "2", {}, {}]

利用 hasOwnProperty

function unique7(arr) {
    var obj = {};
    return arr.filter(function(item, index, arr){
	console.log(obj.hasOwnProperty(typeof item + item), typeof item + item)
        return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)
    })
}
// 都去掉了
// [1, 2, 3, NaN, undefined, null, [], false, 0, "1", "2", {}]

利用 filter

判断当前元素，在原始数组中的第一个索引 === 当前索引值，否则返回当前元素

function unique8(arr) {
  return arr.filter(function(item, index, arr) {
    return arr.indexOf(item, 0) === index;
  });
}
// 无法去除空数组和空对象, NaN 好像不见了
// [1, 2, 3, undefined, null, [], [], false, 0, "1", "2", {}, {}]

利用 reduce 加 includes

MDN 解释， reduce() 方法对数组中的每个元素执行一个由您提供的 reducer 函数(升序执行)，将其结果汇总为单个返回值。

reducer 函数接收4个参数:

1. Accumulator (acc) (累计器)
2. Current Value (cur) (当前值)
3. Current Index (idx) (当前索引)
4. Source Array (src) (源数组)

您的 reducer 函数的返回值分配给累计器，该返回值在数组的每个迭代中被记住，并最后成为最终的单个结果值。

function unique9(arr){
	return arr.reduce((total, cur, index, arr)=>{
		return total.includes(cur) ? total : [...total, cur]
	}, [])
}
// 无法去除空对象和空数组
// [1, 2, 3, NaN, undefined, null, [], [], false, 0, "1", "2", {}, {}]

ES6 Set 加 ... 运算符

function unique10(arr){
	return [...new Set(arr)]
}
// [1, 2, 3, NaN, undefined, null, [], [], false, 0, "1", "2", {}, {}]