数组去重：Map、Set、reduce、filter，for

第一种方法

function qc(arr1){
	let arr=[];
for(let i=0;i<arr1.length;i++){
	if(arr.indexof(arr1[i])==-1){
		arr.push(arr1[i])
		}
	}
	return arr;
}
arr1= [1,2,3,3,3,3,4]
qc(arr1)

第二种方法

let array = [3,2,2,1,1]
let arr=[...new Set(array)]
或let arr = Array.from(new Set(array))
因为new Set 返回的是对象，所以要转成数组

第三种方法

Map类似地图：地图上名字只有一个，给它设置index：1
map.set(v,1) 通过map.key()获取地图名字
Map是对象，偏向hash，不像对象要求key为“字符串”
Set是集合，类似数组，特点是无序

const arr = [3,2,2,1,2,3]
const deduplication = arr =>{
	let map = new Map() 
	arr.forEach(v=>map.set(v,1))
		return [...map.keys()]
}
console.log(deduplication(arr));

遍历原始数组，把数组的每一个元素作为key存到Map，因为Map中不会出现相同的key值，所以最终得到的Map中的所有key值就是去重后的结果。

Map.keys()返回的是新的 Iterator对象，要转成数组则要经过[ …]

（拓展）
Map mdn描述
Map 对象保存键值对，并且能够记住键的原始插入顺序。任何值(对象或者原始值) 都可以作为一个键或一个值。

Map基础梳理
JavaScript 的对象（Object），本质上是键值对的集合（Hash 结构），但是传统上只能用字符串当作键。这给它的使用带来了很大的限制。
为了解决这个问题，ES6 提供了 Map 数据结构。它类似于对象，也是键值对的集合，但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键。也就是说，Object 结构提供了“字符串—值”的对应，Map 结构提供了“值—值”的对应，是一种更完善的 Hash 结构实现。
例如Map构造函数接受一个数组作为其参数：

const map = new Map([
  [1, '张三'],
  [2, '李四']
]);
// 0:{1 => "张三"}
// 1:{2 => "李四"}

除了数组去重，Map还能
1.找到数组中重复的数
2.找到数组中第一个非重复的数
通过给重复的数标记（true或false），从而获取到：存储每一个数字的重复情况。

let arr = [1,1,3,3,2,2]
fuction findRepeat(arr){
let map = new Map();
let array = [];
arr.forEach(v=>{
	if(map.has(v)==true)
		map.set(v,true)
		array.push(v)
	else{
		map.set(v,false)
	}
})
return result;
}

（拓展）Map和Set区别 两者都是对象
Map是键值对结构的对象
Set是成员唯一且无序，类似数组的结构
Set 和 Map 主要的应用场景在于 数据重组 和 数据储存。
Set 是一种叫做集合的数据结构，类似于数组，成员是唯一且无序的，没有重复的值。以 [value, value]的形式储存元素，键值与键名是一致的（或者说只有键值，没有键名）。

Map 是一种叫做字典的数据结构，是以 [key, value] 键值对的形式储存，与对象的区别在于字典不限于字符串-值，可以对象或数组-值。

集合 与 字典 的区别：
共同点：集合、字典 可以储存不重复的值（去重）

const arr = [1, 2, 3, 4, 5, 5, 4, 3, 2, 1];
const set = new Set();
arr.forEach(item => set.add(item));
console.log(set);  // 1, 2, 3, 4, 5
// 数组快速去重
console.log([...new Set(arr)]);  //[1, 2, 3, 4, 5]

Map 对象是键值对集合，和 JSON 对象类似，但是 key 不仅可以是字符串还可以是对象

var map = new Map();
var obj = { name: '小缘', age: 14 };
map.set(obj, '小缘喵');
map.get(obj); // 小缘喵
map.has(obj); // true
map.delete(obj) ;// true
map.has(obj); // false

（拓展）Map和map的区别
Map是数据结构，对象
map是数组方法

（拓展）迭代和遍历的区别
(编程)迭代(iterate) - 按顺序访问线性结构中的每一项
遍历(traversal) - 按规则访问非线性结构中的每一项

第四种方法

const arr= [1,2,2,1,3,3]
const deduplication4 =arr => arr.filter((val,index)=>
	arr.indexOf(val) === index
)
console.log(deduplication4(arr))

数组的indexOf方法记忆错误，返回 的应是数组元素第一次出现的位置（第一次出现的元素index和indexOf值相等）

const duplication3 = arr=>{
   return arr.filter((r,index)=>{
      return  arr.indexOf(r)===index}
      )};
console.log(duplication3(arr))

函数{}一定要return，注意return的是新数组还是旧数组

第五种方法

const arr = [3, 1, 1, 2, 5, 9, 3, 0]
const deduplication3 = arr => arr.reduce((temp, v) => temp.includes(v) ? temp : [...temp, v], [])

console.log(deduplication3(arr))

第六种方法（选看）

let arr = [3, 0, 0, 1, 1, 2, 3, 3, 3, 5, 5]

function deduplication(arr) {
  let hash = {}
  for(let i=0; i<arr.length; i++) {
    if(!hash[arr[i]]) {
      hash[arr[i]] = 1
    } else {
      arr.splice(i, 1)
      i--
    }
  }
  return arr
}

let arr2 = deduplication(arr)
console.log(arr2)
console.log(arr)
console.log(arr === arr2)