关于new Set( )还有哪些是你不知道的

 1、Set 特点:

• Set 对象是值的集合，可以按照插入的顺序迭代它的元素
• Set   中的元素只会出现一次，即 Set 中的元素是唯一的,所以需要判断两个值是否相等
• Set   中+0和 -0 是不同的值,可以使用 Object.is(+0,-0)进行判断返回false ,+0 严格相等于 -0
• Set 对象允许你存储任何类型的唯一值，无论是原始值或者是对象引用
• Set 中NaN 和 undefined 都可以被存储在 Set 中，但是值得注意的是,尽管 NaN !== NaN,但是NaN之间在Set里却被视为相同的值（NaN 被认为是相同的,所以只能存一个）

const set1 = new Set('abc')//{'a','b','c'}
 
set1.add('abc')//{'a','b','c','abc'}
 
const set2 = new Set('aaa')//{'a'}
 
set2.add(undefined)//{'a',undefined}
 
const set3 = new Set(['abc'])//{'abc'}
 
set3.add(NaN)//{'abc',NaN}
 

2、Set 的实例属性:

size: 返回 Set 对象中的值的个数

const set1 = new Set('abc')
console.log(set1.size)// 3
 
 
const set2 = new Set('aaa')
console.log(set2.size)// 1

3、Set 的实例方法:

1)、add( value ): 在Set对象尾部添加一个元素, 返回该 Set 对象

2)、has(value): 判断Set对象中是否有一个元素,返回true/false

3)、clear( ): 移除Set对象内的所有元素

4)、delete( value ): 移除值为 value 的元素，并返回一个布尔值来表示是否移除成功         并且 has(value) 会在此之后返回 false

6)、entries(): 返回一个新的迭代器对象，该对象包含 Set 对象中的按插入顺序排列的所有元素的值的 [value, value] 数组。为了使这个方法和 Map 对象保持相似， 每个值的键和值相等

7)、forEach(( )=>{  }): 按照插入顺序，为 Set 对象中的每一个值调用一次 callBackFn

8)、keys( ):与 values() 方法相同，返回一个新的迭代器对象，该对象包含 Set 对象中的按插入顺序排列的所有元素的值

9)、values( ) : 返回一个新的迭代器对象，该对象包含 Set 对象中的按插入顺序排列的所有元素的值

let set = new Set();
 
 
set.add(1); // Set [ 1 ]
set.add(5); // Set [ 1, 5 ]
set.add(5); // Set [ 1, 5 ]//不变,因为已经存在一个值为 5 的成员了
set.add("abc"); // [ 1, 5, "abc" ]
const obj = {a: 1, b: 2};
set.add(obj);//
 
set.add({a: 1, b: 2}); // obj 指向的是不同的对象，所以可以添加进去
 
set.has(1); // true
set.has(3); // false
set.has(5);  // true
set.has(Math.sqrt(25));  //true Math.sqrt(25) 找25的平方根
set.has("Abc".toLowerCase()); // true  敏感区分大小写
set.has(obj); // true
 
set.size; // 5
 
set.delete(5);  // true，从 set 中移除 5
set.has(5);     // false, 5 已经被移除
 
set.size; // 4，刚刚移除一个值
 
 
for (let item of mySet){
    console.log(item) //按顺序输出 : 1, "abc", {"a": 1, "b": 2}, {"a": 1, "b": 2}
}
 
 
for (let item of mySet.keys()) {
    console.log(item) //按顺序输出 : 1, "abc", {"a": 1, "b": 2}, {"a": 1, "b": 2}
}
 
 
for (let item of mySet.values()) {
     console.log(item) //按顺序输出 : 1, "abc", {"a": 1, "b": 2}, {"a": 1, "b": 2}
}
 
//(key value 相等)
for (let [key, value] of mySet.entries()) {
     console.log(item) //按顺序输出 : 1, "abc", {"a": 1, "b": 2}, {"a": 1, "b": 2}
}
 
// 使用 Array.from 转换 Set 为 Array
var arr = Array.from(set); // [1, "abc", {"a": 1, "b": 2}, {"a": 1, "b": 2}]
 
// Set 和 Array 互换
set2 = new Set([1, 2, 3, 4]);
set2.size;// 4
[...set2];  // [1,2,3,4]
 
// 用 forEach 迭代
set.forEach(function(value) {
  console.log(value);// 依次输出 a,b,c
});

 4、应用:实现常见的基本集合

      const setA = new Set([1, 2, 3, 4]);
      const setB = new Set([2, 3]);
      const setC = new Set([3, 4, 5, 6]);

• 子集

        const isSuperset = (set1, set2) => {
          for (const item of set2) {
            if (!set1.has(item)) {
              return false;
            }
          }
          return true;
        };
        console.log('判断是否是子集', isSuperset(setA, setB));//true
  

• 并集

        const union = (set1, set2) => {
          const res = new Set(set1);
          for (const item of set2) {
            if (!set1.has(item)) {
              res.add(item);
            }
          }
          return res;
        };
        console.log('返回并集', union(setA, setC));// Set [1, 2, 3, 4, 5, 6]
  

• 交集

        const intersection = (set1, set2) => {
          const res = new Set();
          for (const item of set2) {
            if (set1.has(item)) {
              res.add(item);
            }
          }
          return res;
        };
        console.log('返回交集', intersection(setA, setC));// Set [3, 4]
  

• 不同的成员组成一个新的集合

        const symmetricDifference = (set1, set2) => {
          const res = new Set(set1);
          for (const item of set2) {
            if (res.has(item)) {
              res.delete(item);
            } else {
              res.add(item);
            }
          }
          return res;
        };
        console.log(
          '不同的成员组成一个新的集合',
          symmetricDifference(setA, setC)
        );// Set [1, 2, 5, 6]
  

• A中剔除B的成员

        const difference = (set1, set2) => {
          const res = new Set(set1);
          for (const item of set2) {
            res.delete(item);
          }
          return res;
        };
        console.log('A中剔除B的成员', difference(setA, setC));// Set [1, 2 ]