ES6 set 数据结构实现数组和字符串去重

需求：

数组和字符串去重

分析：

去重一般是通过遍历的方法解决，不过ES6 set 数据结构给了我们新的思路，本文重点介绍此方法，后面会附上遍历的相关解法；

实现：

一，set方法

1，set介绍(此介绍参考MDN，如有侵权请联系博主删除，博主邮箱[email protected])

Set 对象允许你存储任何类型的唯一值，无论是原始值或者是对象引用。

// 1，语法
new Set([iterable]);
// 2，语法解释--参数解释
// iterable 如果传递一个可迭代对象，它的所有元素将不重复地被添加到新的 Set中。如果不指定此参数或其值为null，则新的 Set为空。
// 3，语法解释--返回值
// 返回一个新的Set对象。
// 4，简述set
// Set对象是值的集合，你可以按照插入的顺序迭代它的元素。 Set中的元素只会出现一次，即 Set 中的元素是唯一的。
// 5，值相等的定义
/* 
因为 Set 中的值总是唯一的，所以需要判断两个值是否相等。在ECMAScript规范的早期版本中，这不是基于和===操作符中使用的算法相同的算法。具体来说，对于 Sets， +0 （+0 严格相等于-0）和-0是不同的值。然而，在 ECMAScript 2015规范中这点已被更改。有关详细信息，请参阅浏览器兼容性 表中的“value equality for -0 and 0”。
另外，NaN和undefined都可以被存储在Set 中， NaN之间被视为相同的值（尽管 NaN !== NaN）。
*/
// 6，属性和方法
/*
Set.prototype.size
返回Set对象的值的个数
Set.prototype.add(value)
在Set对象尾部添加一个元素。返回该Set对象。
Set.prototype.clear()
移除Set对象内的所有元素。
Set.prototype.delete(value)
移除Set的中与这个值相等的元素，返回Set.prototype.has(value)在这个操作前会返回的值（即如果该元素存在，返回true，否则返回false）。Set.prototype.has(value)在此后会返回false。
Set.prototype.entries()
返回一个新的迭代器对象，该对象包含Set对象中的按插入顺序排列的所有元素的值的[value, value]数组。为了使这个方法和Map对象保持相似， 每个值的键和值相等。
Set.prototype.forEach(callbackFn[, thisArg])
按照插入顺序，为Set对象中的每一个值调用一次callBackFn。如果提供了thisArg参数，回调中的this会是这个参数。
Set.prototype.has(value)
返回一个布尔值，表示该值在Set中存在与否。
Set.prototype.keys()
与values()方法相同，返回一个新的迭代器对象，该对象包含Set对象中的按插入顺序排列的所有元素的值。
Set.prototype.values()
返回一个新的迭代器对象，该对象包含Set对象中的按插入顺序排列的所有元素的值。
Set.prototype[@@iterator]()
返回一个新的迭代器对象，该对象包含Set对象中的按插入顺序排列的所有元素的值。
*/

2，set实现数组去重

var myArray = [1,1,2,2,3,3];
// 用Set构造器将Array转换为Set
var mySet = new Set(myArray);
// 用...(展开操作符)操作符将Set转换为Array
var pureArray = [...mySet]; 
console.log(pureArray); //  [1, 2, 3]

3，set实现字符串去重

var myStr = '112233';
// 用Set构造器将Array转换为Set
var mySet = new Set(myStr);
// 用...(展开操作符)操作符将Set转换为Array
var pureArray = [...mySet]; 
// // join方法转换为数组
var pureString = pureArray.join('');
console.log(pureString);// '123'

二，遍历方法

1，indexOf---数组去重

var myArr= [1,1,2,2,3,3];
function getPureArr(arr){
  var pureArr=[];
  for (var i = 0; i < arr.length; i++) {
     // 如果pureArr没有这个元素，则push进pureArr中
     if(pureArr.indexOf(arr[i])==-1){
      pureArr.push(arr[i]);
     }
  }
  return pureArr;
}
var pureArr = getPureArr(myArr);
console.log(pureArr);//  [1, 2, 3]

var myArr= [1,1,2,2,3,3];
function getPureArr(arr){
  var pureArr=[];
  for (var i = 0; i < arr.length; i++) {
     // 如果当前元素第一次出现的位置等于目前循环的位置，则push进pureArr中
     // 否则认为是之前已出现过，定义为重复元素不push进pureArr中
     if(arr.indexOf(arr[i])==i){
      pureArr.push(arr[i]);
     }
  }
  return pureArr;
}
var pureArr = getPureArr(myArr);
console.log(pureArr);//  [1, 2, 3]

2，sort排序后做相邻比较---数组去重

var myArr= [1,1,2,2,3,3];
function getPureArr(arr){
// 数组排序
  arr.sort();
  var pureArr=[arr[0]];
  for (var i = 1; i < arr.length; i++) {
    // 如果原数组第i个元素和新数组的i-1个元素不相等，则认定不是重复元素
     if(arr[i]!=pureArr[pureArr.length-1]){
      pureArr.push(arr[i]);
     }
  }
  return pureArr;
}
var pureArr = getPureArr(myArr);
console.log(pureArr);//  [1, 2, 3]

3，双层循环---数组去重

var myArr= [1,1,2,2,3,3];
function getPureArr(arr){
  var pureArr=[];
  for (var i = 0; i < arr.length; i++) {
    // 当前元素和所有的之后元素比较 
    for (var j = i+1; j < arr.length; j++) {
      // 如果当前元素等于其后的某一个元素，则让i加1，跳过这个元素，不push进pureArr中
      if(arr[i]===arr[j]){
        ++i;
        // 找到重复元素后不再继续循环，跳出本次i值的循环(内层循环)，继续执行的i的下一个循环(外层循环)
        break;
      }
    }
    // 如果i+1，则会跳过这个元素
    pureArr.push(arr[i]);
  }
  return pureArr;
}
var pureArr = getPureArr(myArr);
console.log(pureArr);//  [1, 2, 3]

3，字符串去重---以数组为媒介，引用以上三个方法

// str.split('')字符串转为数组
var arr = '112233'.split('');
console.log(arr);// ["1", "1", "2", "2", "3", "3"]
// arr.join('')数组转为字符串
var str = ["1", "1", "2", "2", "3", "3"].join('');
console.log(str);