JavaScript之多种方法实现纯数组去重、数组对象去重、splice、continue、filter、indexOf、reduce、includes、concat、forEach、join

---

前言

1、第一部分的纯属组去重在面试中会遇到多一点；第二部分的数组对象会在实际开发中遇到多一点。
2、前端潮咖出品1~9

---

纯属组的数据源

// 全局数据。
let arr =  [1, 2, 2, 4, null, null, '3', 'abc', 3, 5, 4, 1, 2, 2, 4, null, null, '3', 'abc', 3, 5, 4];

---

key唯一性

// 字典(对象)不允许出现重复的下标
// 遍历 array 中每个元素，
// 每遍历一个元素，
// 就以当前元素作为属性名加入字典中，
// 属性值随便写
function statistics(array) {
	// 定义空字典
	let dictionaries = {};
	for (var i = 0; i < array.length; i++) {
		dictionaries[array[i]] = 1;
	}
	
	return dictionaries;
}

// 此时返回的是对象
// 需要转为数组
console.log(statistics(arr)); 
// {1: 1, 2: 2, 4: 4, null: null, 3: "3", abc: "abc", 3: 3, 5: 5}

// 把对象还原为数组
// 遍历字典，仅获取属性名，不要属性值
var result = [], 
	i = 0;
	
for(result[i++] in statistics(arr));
console.log(result); 
// [1, 2, 4, null, "3", "abc", 3, 5]

---

利用对象的key唯一

对象的key不可重复，否则后者将覆盖前者。利用该特性，实现数组去重，遍历数组，将数组的每一项做为对象的key值。

function noRepeat(arr) {
	let obj = {};
	
	for (let i = 0; i < arr.length;) {
		let item = arr[i];
		
		if (obj[item] !== undefined) {
			arr.splice(i, 1);
			continue;
		} else {
			// 数组塌陷的解决方案
			i++;
			obj[item] = item;
		}
	}
	
	return arr;
}

console.log(noRepeat(noRepeat(arr)));
// arr: [1, 2, 4, null, "3", "abc", 3, 5]

---

交换元素位置从而替换调splice方法

上述方法存在一定的性能问题，也就是说，基于splice实现删除性能不太好，当前项被删除后，随后每一项的索引都要向前移动一位，数据量较庞大时，一定会影响性能。
基于以上考虑，交换元素的位置，效率会更高一点，若当前元素重复，则与数组最后一位元素交换位置，i–再次进行判断即可，同时length操作数组的长度实现删除数组的最后一个元素，这样便不会影响到数组中其他元素。

let obj = {};
for (let i = 0; i < arr.length; i++) {
	let item = arr[i];
	if (obj[item] !== undefined) {
		arr[i] = arr[arr.length-1]
		arr.length--;
		i--; 
		continue;
	}
	obj[item] = item
}
// arr: [1, 2, 4, null, "3", "abc", 3, 5]

---

Array.filter + Array.indexOf

filter() 方法：创建一个新数组，新数组中的元素是指定数组中符合某种条件的所有元素。如果没有符合条件的元素则返回空数组。
语法：array.filter(function(item,index,arr))
filter() 不会对空数组进行检测。
filter() 不会改变原始数组。
原理：返回 item 第一次出现的位置等于当前的index的元素。

let newArr = arr.filter((item, index) => arr.indexOf(item) === index);  
// [1, 2, 4, null, "3", "abc", 3, 5]

---

Array.filter + Object.hasOwnProperty

hasOwnProperty() 方法：返回一个布尔值，表示对象自身属性中是否具有指定的属性。
原理：利用对象的键名不可重复的特点。

let obj = {};
arr.filter(item => obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true));
// [1, 2, 4, null, "3", "abc", 3, 5]

---

Array.reduce + Array.includes

reduce() 方法：接收一个函数作为累加器，数组中的每个值从左到右开始计算，最终计算为一个值。
语法：arr.reduce(function(total, currValue, currIndex, arr), initValue)
reduce() 不会对空数组执行回调函数。
total：必需，初始值，或者计算结束后的返回值。
currValue：必需，当前元素。
currIndex：可选，当前元素的索引。
arr：可选，当前数组对象。
initValue：可选，累加器初始值。
一个空数组调用reduce()方法且没有提供初始值，会报错。
一个空数组调用reduce()方法且提供了初始值，将直接返回该初始值，不会调用 callback 函数。
非空数组调用reduce()提供初始值，则total将会等于初始值，且 currValue 从第一个元素开始；若没有提供初始值，则 total 会等于的第一个元素值，且 currValue将会从第二个元素开始。

let newArr = arr.reduce((accu, cur) => {
	return accu.includes(cur) ? accu : accu.concat(cur);  // 1. 拼接方法
	// return accu.includes(cur) ? accu : [...accu, cur]; // 2. 扩展运算
}, []);
// [1, 2, 4, null, "3", "abc", 3, 5]

---

Array.indexOf

indexOf() 方法：返回数组中某个指定的元素位置。该方法遍历数组，查找有无对应元素并返回元素第一次出现的索引，未找到指定元素则返回 -1。

let newArr = [];
for (var i = 0; i < arr.length; i++) {
	if (newArr.indexOf(arr[i]) === -1) newArr.push(arr[i]);  
}
//等同于 forEach 写法
arr.forEach(item => newArr.indexOf(item) === -1 ? newArr.push(item) : '');
console.log(newArr);  // [1, 2, 4, null, "3", "abc", 3, 5]

---

Array.includes

includes() 方法：用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false。

let newArr = [];
for (var i = 0; i < arr.length; i++) {
	if (!newArr.includes(arr[i]))  newArr.push(arr[i]);
}
//等同于 forEach 写法
arr.forEach( item => !newArr.includes(item) ? newArr.push(item) : '');
console.log(newArr);  // [1, 2, 4, null, "3", "abc", 3, 5]

---

new Set + 扩展运算符 || Array.from

ES6 提供了新的数据结构 Set。类似于数组，但是成员的值都是唯一的，没有重复的值。
Set本身是一个构造函数，可以接受一个具有 iterable 接口数据结构作为参数（如数组，字符串），用来初始化。

let newArr = [...new Set(arr)];      
// [1, 2, 4, null, "3", "abc", 3, 5]
let newArr = Array.from(new Set(arr));      
// [1, 2, 4, null, "3", "abc", 3, 5]
let newStr = [...new Set('ababbc')].join(''); 
// 'abc'

---

new Map

ES6 提供了新的数据结构 Map 。类似于对象，也是键值对的集合，但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键。
set方法设置键名key对应的键值为value，然后返回整个 Map 结构。如果key已经有值，则键值会被更新，否则就新生成该键。
get方法读取key对应的键值，如果找不到key，返回undefined。
has方法返回一个布尔值，表示某个键是否在当前 Map 对象之中。

let map = new Map();
let newStr = [];
for (let i = 0; i < arr.length; i++) {
	if (!map.has(arr[i])) {
		map.set(arr[i], true);
		newStr.push(arr[i]);
	}
}
console.log(newArr); 
// [1, 2, 4, null, "3", "abc", 3, 5]

------------------------

---

数组对象的数据源

let originData = [
	{ id: 1, age: 23, name: '张三' },
	{ id: 2, age: 27, name: '王五' },
	{ id: 3, age: 13, name: '李四' },
	{ id: 4, age: 19, name: '王五' },
	{ id: 5, age: 32, name: '赵六' },
	{ id: 6, age: 18, name: '张三' },
];

---

数组对象去重(一)

// 利用reduce方法遍历数组, reduce第一个参数是遍历需要执行的函数，
// 第二个参数是item的初始值
function reduces(datas) {
	var obj = {};
	
	datas = datas.reduce(function (item, next) {
		obj[next.name] ? "" : (obj[next.name] = true && item.push(next));
		
		return item;
	}, []);
	
	return datas;
}

console.log(reduces(originData));

---

数组对象去重(二)

// 参数arr：源数据
// 参数field：根据name字段去重
function unique(arr, field) {
	let map = new Map();
	
	arr.forEach((item) => {
		if (!map.has(item[field])) map.set(item[field], item);
	});
	
	return [...map.values()];
}

console.log(unique(originData, 'name'));