1. 要想搞明白数组去重的各种方案，第一步要做的事就是什么是重复的元素，先来看一段代码结果
    3. /**
    4.  * 谈到数组去重，几乎是面试必备的一道开胃菜
    5.  * 要想数组去重，第一件事就是有一个数组
    6.  */
    7. // 首先第一步
    8. console.log(1 === 1); // true
    9. console.log("1" === "1"); // true
    10. console.log("true" === "true"); // true
    11. console.log(false === false); // true
    12. console.log(undefined === undefined); // true
    13. console.log(null === null); // true
    15. console.log(NaN === NaN); // false
    16. console.log({} === {}); // false
    17. console.log([] === []); // false
    18. 接着第二步：准备含有重复元素的目标数组
    20. let targetArr = ["1", "1", 1, 1, true, true, undefined, undefined, null, null];
    22. console.log(targetArr);
    23. 第三步：写去重方法,这时候才是正是写方法的时候
    25. /**
    26.  * desc 第一种方案 双层for循环
    27.  */
    28. function unique1(arr) {
    29.   let result = []; // 结果数组
    30.   for (let i = 0, len = arr.length; i < len; i++) {
    31.     for (var j = 0, resLen = result.length; j < resLen; j++) {
    32.       if (arr[i] === result[j]) {
    33.         break;
    34.       }
    35.     }
    37.     if (j === result.length) {
    38.       result.push(arr[i]);
    39.     }
    40.   }
    41.   return result;
    42. }
    43. /**
    44.  * desc 第二种方案 indexOf
    45.  */
    47. const unique2 = (arr) => {
    48.   let result = [];
    49.   for (let i = 0, len = arr.length; i < len; i++) {
    50.     if (result.indexOf(arr[i]) === -1) {
    51.       // 在结果数组中没有找到元素
    52.       result.push(arr[i]);
    53.     }
    54.   }
    55.   return result;
    56. };
    57. /**
    58.  * desc 第三种方案 先给数组排序结合 sort函数
    59.  */
    61. const unique3 = (target) => {
    62.   target.sort();
    63.   let result = [target[0]]; // 取出第一个元素
    65.   for (let i = 1; i < target.length; i++) {
    66.     target[i] !== target[i - 1] && result.push(target[i]); // 当前项和它的前一项不同的时候，才添加进结果数组
    67.   }
    68.   return result;
    69. };
    70. /**
    71.  * desc 第四种方案 使用filter 函数结合 indexof
    72.  */
    74. const unique4 = (target) => {
    75.   return target.filter((item, index) => {
    76.     return target.indexOf(item) === index; // 数组的下标与检索的下标一致
    77.   });
    78. };
    79. /**
    80.  * desc 第五种方案 使用对象的键值对 结合obj.hasOwnProperty()
    81.  */
    83. const unique5 = (target) => {
    84.   let obj = {}; // 初始化一个空的对象
    85.   let result = new Array();
    86.   result = target.filter((item, index) =>
    87.     // typeof item + item 主要是考虑到 对象的key 数值1 会被搞成 '1'
    88.     obj.hasOwnProperty(typeof item + item)
    89.       ? false
    90.       : (obj[typeof item + item] = true)
    91.   );
    92.   return result;
    93. };
    94. /**
    95.  * desc 第六种方案 使用ES6的新语法Set
    96.  *
    97.  */
    98. const unique6 = (target) => {
    99.   // Set 对象允许你存储任何类型的唯一值，无论是原始值或者是对象引用。
    100.   let x = new Set(target); // Set { '1', 1, true, null }
    102.   return [...x]; // 转为数组
    103. };
    104. /**
    105.  * desc 第七种方案 使用ES6的Array.from
    106.  *
    107.  */
    108. const unique7 = (target) => {
    109.   // Set 对象允许你存储任何类型的唯一值，无论是原始值或者是对象引用。
    110.   let x = new Set(target); // Set { '1', 1, true, null }
    112.   return Array.from(x); // 转为数组
    113. };
    114. /**
    115.  * desc 第八种方案 使用哈希表
    116.  *
    117.  */
    119. const unique8 = (target) => {
    120.   let result = []; // 结果数组
    121.   let hash = {};
    122.   for (let ele of target) {
    123.     if (!hash[ele]) {
    124.       // hash 中没有数组中的元素
    125.       result.push(ele); // 把元素放进去
    126.       hash[ele] = true; // hash中已经存在了标记为true 下次循环就不会接着往结果数组中放相同的元素了
    127.     }
    128.   }
    129.   return result;
    130. };
    131. /**
    132.  * desc 第九种方案 使用Map 类型
    133.  * 缺点 hash中存在相同的 key 就不往下找了， 但 '1' 和 1 是不同的元素
    134.  * 请同学自行测试吧哈哈~
    135.  */
    137. const unique9 = (target) => {
    138.   let map = new Map(); // 初始化 map
    139.   let result = new Array(); // 初始化 数组
    140.   for (let i = 0; i < target.length; i++) {
    141.     if (map.has(target[i])) {
    142.       map.set(target[i], true);
    143.     } else {
    144.       map.set(target[i], false);
    145.       result.push(target[i]);
    146.     }
    147.   }
    148.   return result;
    149. };
    150. /**
    151.  * desc 第十种方案 双层for循环变体
    152.  *
    153.  *
    154.  */
    156. const unique10 = (target) => {
    157.   //   let result = [];
    159.   for (let i = 0; i < target.length; i++) {
    160.     for (let j = i + 1; j < target.length; j++) {
    161.       if (target[i] === target[j]) {
    162.         // 如果两项元素相同的话，则从目标元素中删除一个
    163.         target.splice(j, 1);
    164.         // splice 会改变原数组，所以相关的长度都要减去一
    165.         i--;
    166.         j--;
    167.       }
    168.     }
    169.   }
    171.   return target;
    172. };
    173. /**
    174.  * desc 第十一种方案 数据的遍历结合includes
    175.  *
    176.  *
    177.  */
    179. const unique11 = (target) => {
    180.   let result = [];
    181.   for (let ele of target) {
    182.     // 其中 ele 是每一目标元素中每一元素
    183.     !result.includes(ele) && result.push(ele); // 如果结果数组中没有ele就添加进去
    184.   }
    185.   return result;
    186. };
    187. /**
    188.  * desc 第十二种方案 数据reduce
    189.  *
    190.  *
    191.  */
    193. const unique12 = (target) => {
    194.   return target.reduce((previousValue, currentValue, currentIndex) => {
    195.     return previousValue.includes(currentValue)
    196.       ? previousValue
    197.       : [...previousValue, currentValue];
    198.   }, []);
    199. };
    200. console.log(unique1(targetArr)); // ["1", 1, true, undefined, null]
    201. console.log(unique2(targetArr)); // ["1", 1, true, undefined, null]
    202. console.log(unique3(targetArr)); // ["1", 1, null, true, undefined]
    203. console.log(unique4(targetArr)); // ["1", 1, null, true, undefined]
    204. console.log(unique5(targetArr)); // ["1", 1, null, true, undefined]