关于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
5. entries(): 返回一个新的迭代器对象，该对象包含 Set 对象中的按插入顺序排列的所有元素的值的 [value, value] 数组。为了使这个方法和 Map 对象保持相似， 每个值的键和值相等
6. forEach(( )=>{  }): 按照插入顺序，为 Set 对象中的每一个值调用一次 callBackFn
7. keys( ):与 values() 方法相同，返回一个新的迭代器对象，该对象包含 Set 对象中的按插入顺序排列的所有元素的值
8. 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 ]