JavaScipt数组去重

	// 方法1  双层循环
	// var array = [1,1,"1","1"];
	// function unique(array) {
	// 	// res用来存储结果
	// 	var res = [];
	// 	for(var i = 0; i < array.length; i++) {
	// 		for(var j = 0; j < res.length; j++) {
	// 			if(array[i]  === res[j]) {
	// 				break;
	// 			}
	// 		}
	// 		// 若是array[i]是唯一的，那么执行完循环，j等于res.length
	// 		if(j === res.length) {
	// 			res.push(array[i])
	// 		}
	// 	}
	// 	return res;
	// }
	// console.log(unique(array)); //[1,"1"]
	// 在这个方法中使用循环嵌套，最外层循环array，里面循环res，若是array[i]的值跟res[j]的值相等，就跳出循环；若是不等于就说明元素是唯一的，这时候j的值就会等于res的长度，根据这个特色进行判断，将值添加进res


	// 方法2  indexOf -1
	// 使用indexOf能够简化内层循环
	// var array = [2,2,"2","2"];
	// function unique(array) {
	// 	var res = [];
	// 	for(var i = 0; i < array.length; i++) {
	// 		var current = array[i];
	// 		if(res.indexOf(current) === -1) {
	// 			res.push(current)
	// 		}
	// 	}
	// 	return res;
	// }
	// console.log(unique(array));  //[2,"2"]


	// 方法3  ES6
	// 可使用Set和Map数据结构，以Set为例，ES6提供了新的数据结构Set，它相似于数组，可是成员的值都是惟一的，没有重复的值
	// Set
	// var array = [3,3,"3","3"];
	// function unique(array) {
	// 	return Array.from(new Set(array));
	// }
	// console.log(unique(array));  //[3,"3"]
		// 能够简化为：
		// function unique(array) {
		// 	return [...new Set(array)];
		// }
		// console.log(unique(array));  //[3,"3"]
			// 还能够简化为: 
			// var unique = (a) => [...new Set(a)]

	// Map
	// var array = [3,3,"3","3"];
	// function unique(array) {
	// 	const seen = new Map()
	// 	return array.filter((a) => !seen.has(a) && seen.set(a,1))
	// }
	// console.log(unique(array));  //[3,"3"]


	// 方法4  排序后去重
	// 先将要去重的数组使用sort方法排序后，相同的值会被排在一块儿，而后就能够只判断当前元素与上一个元素知否相同，相同就说明重复，不相同就添加进res
	// var array = [4,4,"4","4"];
	// function unique(array) {
	// 	var res = [];
	// 	var sortedArray = array.concat().sort();
	// 	var seen;
	// 	for(var i = 0; i < sortedArray.length; i++) {
	// 		if(!i || seen !== sortedArray[i]) {
	// 			res.push(sortedArray[i]);
	// 		}
	// 		seen = sortedArray[i];
	// 	}
	// 	return res;

	// }
	// console.log(unique(array));  //[4,"4"]
	// 若是对一个已经排好序的数组去重，这种方法的效率高于indexOf

	// 方法5  filter
	// 使用此方法来简化外层循环
	// var array = [5,5,"5","5"];
	// function unique(array) {
	// 	var res = array.filter(function(item,index,array) {
	// 		return array.indexOf(item) === index;
	// 	})
	// 	return res;
	// }
	// console.log(unique(array));  //[5,"5"]

	// 排序去重的方法：
	// var array = [5,5,"5","5"];
	// function unique(array) {
	// 	return array.concat().sort().filter(function(item,index,array) {
	// 		return !index || item !== array[index -1]
	// 	})
	// }
	// console.log(unique(array));

	// 方法6 Object键值对
	// 这种方法是利用一个空的 Object 对象，咱们把数组的值存成 Object 的 key 值，好比 Object[value1] = true，在判断另外一个值的时候，若是 Object[value2]存在的话，就说明该值是重复的。示例代码以下：

// var array = [1, 2, 1, 1, '1'];

// function unique(array) {
//     var obj = {};
//     return array.filter(function(item, index, array){
//         return obj.hasOwnProperty(item) ? false : (obj[item] = true)
//     })
// }

// console.log(unique(array)); // [1, 2]
// 咱们能够发现，是有问题的，由于 1 和 '1' 是不一样的，可是这种方法会判断为同一个值，这是由于对象的键值只能是字符串，因此咱们可使用 typeof item + item 拼成字符串做为 key 值来避免这个问题：

// var array = [1, 2, 1, 1, '1'];

// function unique(array) {
//     var obj = {};
//     return array.filter(function(item, index, array){
//         return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)
//     })
// }

// console.log(unique(array)); // [1, 2, "1"]
// 然而，即使如此，咱们依然没法正确区分出两个对象，好比 {value: 1} 和 {value: 2}，由于 typeof item + item 的结果都会是 object[object Object]，不过咱们可使用 JSON.stringify 将对象序列化：

// var array = [{value: 1}, {value: 1}, {value: 2}];

// function unique(array) {
//     var obj = {};
//     return array.filter(function(item, index, array){
//         console.log(typeof item + JSON.stringify(item))
//         return obj.hasOwnProperty(typeof item + JSON.stringify(item)) ? false : (obj[typeof item + JSON.stringify(item)] = true)
//     })
// }

// console.log(unique(array)); // [{value: 1}, {value: 2}]

// 方法7 unique API
// 写一个名为 unique 的工具函数，根据一个参数 isSorted 判断传入的数组是不是已排序的，若是为 true，就判断相邻元素是否相同，若是为 false，就使用 indexOf 进行判断

// var array1 = [1, 2, '1', 2, 1];
// var array2 = [1, 1, '1', 2, 2];

// // 初版
// function unique(array, isSorted) {
//     var res = [];
//     var seen = [];

//     for (var i = 0, len = array.length; i < len; i++) {
//         var value = array[i];
//         if (isSorted) {
//             if (!i || seen !== value) {
//                 res.push(value)
//             }
//             seen = value;
//         }
//         else if (res.indexOf(value) === -1) {
//             res.push(value);
//         }        
//     }
//     return res;
// }

// console.log(unique(array1)); // [1, 2, "1"]
// console.log(unique(array2, true)); // [1, "1", 2]
// 优化

// 新需求：字母的大小写视为一致，好比'a'和'A'，保留一个就能够了！

// 虽然能够先处理数组中的全部数据，好比将全部的字母转成小写，而后再传入unique函数，可是有没有方法能够省掉处理数组的这一遍循环，直接就在去重的循环中作呢？

// var array3 = [1, 1, 'a', 'A', 2, 2];

// // 第二版
// // iteratee 英文释义：迭代 重复
// function unique(array, isSorted, iteratee) {
//     var res = [];
//     var seen = [];

//     for (var i = 0, len = array.length; i < len; i++) {
//         var value = array[i];
//         var computed = iteratee ? iteratee(value, i, array) : value;
//         if (isSorted) {
//             if (!i || seen !== computed) {
//                 res.push(value)
//             }
//             seen = computed;
//         }
//         else if (iteratee) {
//             if (seen.indexOf(computed) === -1) {
//                 seen.push(computed);
//                 res.push(value);
//             }
//         }
//         else if (res.indexOf(value) === -1) {
//             res.push(value);
//         }        
//     }
//     return res;
// }

// console.log(unique(array3, false, function(item){
//     return typeof item == 'string' ? item.toLowerCase() : item
// })); // [1, "a", 2]
// 在这一版也是最后一版的实现中，函数传递三个参数：

// array：表示要去重的数组，必填

// isSorted：表示函数传入的数组是否已排过序，若是为 true，将会采用更快的方法进行去重

// iteratee：传入一个函数，能够对每一个元素进行从新的计算，而后根据处理的结果进行去重