数组去重的方法

1、双重for循环 + splice( )

思路：数组的 splice() 方法删除当前重复元素，第一个参数是开始的值，第二个参数是需要删除的个数。

      let arr = ["a", "the", "a", "b", "test", "good", "the", "a", "good", "a"];
      //   第一次循环数组
      for (let i = 0; i < arr.length; i++) {
        // 第二次循环数组
        for (let j = i + 1; j < arr.length; j++) {
          // 判断条件是：当前数和当前数后一位数相等时
          if (arr[i] == arr[j]) {
            // 数组的方法删除当前重复的数
            arr.splice(j, 1);
            // 删除一个数后，数组长度会发生改变
            // 所以需要进行自减维持从替换位置比较
            j--;
          }
        }
      }
      // 输出结果为： ['b', 'test', 'the', 'good', 'a']
      console.log(arr);

2、for 循环 + indexOf( ) 

思路：数组的 indexOf( ) 方法判断是否存在该数，如果不存在则返回 -1。

  let arr = [1, 2, 3, 4, 5, 2, 1, 2, 3, 4, 1];
      // 定义空数组接收新数组
      let temp = [];
      for (let i = 0; i < arr.length; i++) {
        // 判断新数组是否存在该数，不存在则返回-1
        if (temp.indexOf(arr[i]) === -1) {
          // 如果不存在该数则把它push()到新数组
          temp.push(arr[i]);
        }
      }
      // 输出结果为： [1，2，3，4，5]
      console.log(temp);

 3、for 循环 + includes ( ) 

思路：数组的 includes ( ) 方法判断某一数组是否包含某元素  返回的是一个布尔值。

let arr = [1, 2, 3, 4， 5, 2, 1, 2];
      // 定义空数组接收新数组
      let result = [];
      for (let i = 0; i < arr.length; i++) {
        // 判断新数组是否存在该数，不存在则返回false
        if (!result.includes(arr[i])) {
          // 如果不存在该数则push()到新数组
          result.push(arr[i]);
        }
      }
      // 输出结果为：[1,2,3,4,5]
      console.log(result);

 4、new Set( )

思路：ES6中新增的数据类型Set ，特点是其值总是唯一的、不重复的。

 let arr = [1, 2, 4, 3, 2, 1, 4, 5];
      // 使用...运算符展开去重的数组
      let result = [...new Set(arr)];
     // 输出结果为： [1, 2, 4, 3, 5]
      console.log(result);

5、new Set( ) + Array.from( )

思路：利用Set不重复的特点结合Array.from( )方法将其转化为真实的数组。

 let arr = [1, 2, 4, 3, 2, 1, 4, 5];
      // Array.from()将set去重后的数值变成真实的数组
      let result = Array.from(new Set(arr));
     // 输出结果为： [1, 2, 4, 3, 5]
      console.log(result);

 6、filter( ) + indexOf( ) 

思路：使用 indexOf( ) 做判断条件，filter( )创建新数组通过返回值为true或false决定是否保留。

 let arr = [1, 2, 4, 3, 2, 1, 4, 5];
      // 语法：Array.filter(function(currentValue, index, arr), thisValue)
      let result = arr.filter((item, index, self) => {
        // 当前元素,在原始数组中的第一个索引 === 当前索引值，
        return self.indexOf(item) == index;
      });
      // 输出结果为：[1, 2, 4, 3, 5]
      console.log(result);

7、reduce( ) + includes( )

思路：reduce( )遍历和传入一个空数组作为去重后的新数组，然后内部判断新数组中是否存在当前遍历的元素，不存在就插入新数组。

 let arr = [1, 3, 4, 2, 1, 4, 2, 5, 3];
      // 语法：Array.reduce(function(total, currentValue, currentIndex, arr), initialValue)
      // total：初始值或计算结束后的返回值, currentValue：当前元素。这两个参数是必填
      const newArray = arr.reduce((newArr, element) => {
        if (!newArr.includes(element)) {
          newArr.push(element);
        }
        return newArr;
      }, []);
    // 输出结果为： [1, 3, 4, 2, 5]
      console.log(newArray);

8、for循环 + sort( )

思路：首先利用 sort( ) 进行排序。进行循环，如果原数组的第 i 项和新数组的 i - 1 项不一致，就push进去。

  let arr = [1, 2, 3, 1, 3, 5, 4, 2, 1, 3];
      let newArray = [];
      // 首先对原数组进行排序
      arr = arr.sort();
      for (let i = 0; i < arr.length; i++) {
        // 判断条件：当前元素是否与下一个元素相等
        arr[i] == arr[i + 1] ? newArray : newArray.push(arr[i]);
      }
    // 输出结果为：[1, 2, 3, 4, 5]
      console.log(newArray);

9、new Map( )

思路：利用Map的键值对同名覆盖，再将Map转数组。

  let arr = [1, 2, 3, 2, 4, 1, 5, 2, 4, 2];
      // map()方法:返回一个新数组,不会修改原数组,且不会对空数组进行检测。
      let map = new Map();
      let newArr = [];
      for (let i = 0; i < arr.length; i++) {
        // has()：检测map对象中键是否存在，存在返回true，不存在返回false。
        if (!map.has(arr[i])) {
          // set():为map对象添加键值对,方法里里面跟两个参数（键,值）,如果只传入一个参数,则值为undefine。
          map.set(arr[i], true);
          newArr.push(arr[i]);
        }
      }
    // 输出结果为：[1, 2, 3, 4, 5]
      console.log(newArr);