数组去重--JS

const test = ["a", "b", "c", "d", "a", "a", "c", "e",
  "f", "g", "h", "i", "j", "k", "l", "f", "g", "h"];

1.for循环

使用for嵌套for,双层循环,外层循环元素,内层循环时比较值。
值相同使用splice删除这个值

//去除数组中重复的数字
//获取数组中的每一个元素
for (let i = 0; i < test.length; i++) {
  //获取当前元素后的所有元素
  for (let j = i + 1; j < test.length; j++) {
    //判断两个元素的值是否相等
    if (test[i] === test[j]) {
      //如果相等，则证明出现了重复元素，则删除j对应的元素
      test.splice(j, 1);
      //当删除了当前j所在的元素以后，后边的元素会自动补位
      //此时将不会载比较这个元素,我需要在比较下一次j所在位置的元素
      j--;
    }
  }
}

2.new Set

const test2 = ["a", "b", "c", "d", "a", "a", "c", "e",
  "f", "g", "h", "i", "j", "k", "l", "f", "g", "h"];

使用ES6 Set去重(Set是无重复值的有序列表,会自动移除重复的值)
…扩展运算符把拥有Iterator 接口的对象转化为以逗号分隔的参数序列

console.log(new Set(test2))//{ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l' }
const result = [...new Set(test2)];
console.log(result, 'set');

3.递归

const test3 = ["a", "b", "c", "d", "a", "a", "c", "e",
  "f", "g", "h", "i", "j", "k", "l", "f", "g", "h"];

创建一个变量firstEl用于保存数组中的第一个元素，然后循环遍历数组，
如果数组中出现和firstEl相等的元素，就把这个变量删除，
循环结束，把第一个元素存储到result中，
接着判断数组中是否还有值，如果有，就调用递归

function deleteRepeatEl(array, result) {
  const firstEl = array[0];
  for (let i = 0; i < array.length; i++) {
    if (firstEl === array[i]) {
      array.splice(i, 1);
      i--;
    }
  }
  result.push(firstEl);
  if (array.length > 0) return deleteRepeatEl(array, result);
  return result;
}

console.log(deleteRepeatEl(test3, []))

4.indexOf

const test4 = ["j", "k", "l", "a", "b", "c", "d", "a", "a", "c", "e",
  "f", "g", "h", "i", "j", "k", "l", "f", "g", "h"];

使用indexOf去重–indexOf查找指定元素第一次出现在数组中的下标

新建一个空数组，for循环原数组，判断空数组中是否存在当前元素，如果有相同的值则跳过，没有相同的则push进数组

function deleteRepeatEl2(array) {
  const newArray = [];
  for (let i = 0; i < array.length; i++) {
    if (newArray.indexOf(array[i]) === -1) {
      newArray.push(array[i]);
    }
  }
  return newArray;
}

console.log(deleteRepeatEl2(test4))

5.使用filter + indexOf去重

const test6 = ["j", "k", "l", "a", "b", "c", "d", "a", "a", "c", "e",
  "f", "g", "h", "i", "j", "k", "l", "f", "g", "h"];

function deleteRepeatEl3(array) {
  const result = array.filter((v, index) => {
 // indexOf每次从头到尾地检索array数组，返回第一次出现的位置（索引）
    if (index === array.indexOf(v)) {
      return v;
    }
  });
  return result;
}
console.log(deleteRepeatEl3(test6))

6.map

const test7 = ["j", "k", "l", "a", "b", "c", "d", "a", "a", "c", "e",
  "f", "g", "h", "i", "j", "k", "l", "f", "g", "h"];

使用Map数组结构去重，由于Map数组不会出现相同的key值，创建一个空的Map数据结构，遍历原数组，把原数组中的每一个值作为key存储到Map中，最终实现去重。

function deleteRepeatEl4(array) {
  const mapArray = new Map();
  for (let i = 0; i < array.length; i++) {
    mapArray.set(array[i]);
  }

  console.log(mapArray, '--')
  //map是可迭代的，for...of 返回键值
  const result = [];
  //方法一、
  // for (let v of mapArray) {
  //   result.push(v[0]);v==>[key,value]
  // }
  //方法二、
   // for (const [key, value] of mapArray) {
  //   result.push(key);
  // }
  //方法三、
  // for (const [key, value] of mapArray.entries()) {
  //   result.push(key);
  // }
  //方法四、
  for (const key of mapArray.keys()) {
    result.push(key)
  }
  return result.sort();
}
console.log(deleteRepeatEl4(test7));

mapArray打印结果：
Map(12) {
  'j' => undefined,
  'k' => undefined,
  'l' => undefined,
  'a' => undefined,
  'b' => undefined,
  'c' => undefined,
  'd' => undefined,
  'e' => undefined,
  'f' => undefined,
  'g' => undefined,
  'h' => undefined,
  'i' => undefined
} --