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：傳入一個函數，能夠對每一個元素進行從新的計算，而後根據處理的結果進行去重