ES6 新增 用于存储唯一值的集合，无论是基本类型还是引用类型 可以理解为加强型的数组，常用于数组去重

* 只有值没有键
* 值是唯一的
* 严格类型约束
* 有序的
**

声明定义

new Set(value)**

* 当 value 中的值

**params** { array } value **return** { Set }

var obj = { name: "zhangsan" };
var set1 = new Set([1, 2, 3, 3, 2, 1]);
var set2 = new Set([obj, obj]);
var set3 = new Set("12345");
console.log(set1);    // Set(3) {1, 2, 3}
console.log(set2);    // Set(1) {{ name: "zhangsan" }}
console.log(set3);    // Set(5) {"1", "2", "3", "4", "5"}

**

元素管理

set.size

**_desc_** 获取数量 **params** { Set } set **return** { number }

var set = new Set([1, 2, 3, 4, 5]);
console.log(set.size);    // 5

set.add(value)

* 支持链式操作

**_desc_** 添加元素 **params** { Set } set **params** { any } value **return** { Set } 执行添加操作后的 Set

var set = new Set();
set.add(1).add(2).add(3);
console.log(set);    // Set(3) {1, 2, 3}

**

set.delete(value)**

**_desc_** 删除元素 **params** { Set } set **params** { any } value **return**_ { boolean }

var set = new Set([1, 2, 3]);
console.log(set);    // Set(3) {1, 2, 3}
set.delete(1);
console.log(set);    // Set(2) {2, 3}

**

set.clear()**

**_desc_** 清空 Set 中所有元素 **params** { Set } set **return**_ { void }

var set = new Set([1, 2, 3]);
console.log(set);    // Set(3) {1, 2, 3}
set.clear();
console.log(set);    // Set(0) {}

set.has(value)**

**_desc_** 检测元素是否存在 **params** { Set } set **params** { any } value **return**_ { boolean }

var set = new Set([1, 2, 3]);
var bool = set.has("1");
console.log(bool);    // false, Set 是严格类型约束的

迭代器

因为 Set 只有值没有键，*set.keys() 和 set.values()** 结果相同

set.keys()

**params** { Set } set **return**_ { SetIterator } 值组成的 Set 迭代对象

var set = new Set(["name", "age"]);
console.log(set.keys());    // SetIterator { "name", "age" }

set.values()

**params** { Set } set **return**_ { SetIterator } 值组成的 Set 迭代对象

var set = new Set(["name", "age"]);
console.log(set.values());    // SetIterator { "name", "age" }

set.entries()

**params** { Set } set **return**_ { SetIterator } 值和值组成的 Set 迭代对象

var set = new Set(["name", "age"]);
console.log(set.entries());    // SetIterator { "name" => "name", "age" => "age" }

数组转换

* Set 类型转换为数组类型

展开运算符

var set = new Set([1, 2, 3, 4, 5]);
console.log(set);                // Set(5) {1, 2, 3, 4, 5}
console.log([...set]);    // [1, 2, 3, 4, 5]

Array.from

var set = new Set([1, 2, 3, 4, 5]);
console.log(set);                            // Set(5) {1, 2, 3, 4, 5}
console.log(Array.from(set));    // [1, 2, 3, 4, 5]

循环遍历

for of

* 先通过迭代器操作，获取 Set 迭代对象，再进行循环遍历操作

var set = new Set(["name", "age"]);
for(let key of set.keys()) {
    console.log(key);        // "name" --->  "age"
}
for(let value of set.values()) {
    console.log(value);    // "name" --->  "age"
}

forEach

* 直接对 Set 操作

var set = new Set(["name", "age"]);
set.forEach((value, key) => {
    console.log(`${key}=>${value}`);    // "name=>name" ---> "age=>age"
})

交集

获取两个集合中共同存在的元素

var set1 = new Set([1, 2, 3]);
var set2 = new Set([3]);
var result = new Set(
    [...set1].filter(item => set2.has(item))
);
console.log(result);    // Set(1) {3}

差集

集合 A 中存在但集合 B 中不存在的元素集合

var set1 = new Set([1, 2, 3]);
var set2 = new Set([3]);
var result = new Set(
    [...set1].filter(item => !set2.has(item))
);
console.log(result);    // Set(2) {1, 2}

并集

两个集合合并成一个集合，并且内部没有重复元素

var set1 = new Set([1, 2, 3]);
var set2 = new Set([3, 4]);
var result = new Set([...set1, ...set2]);
console.log(result);    // Set(4) {1, 2, 3, 4}

WeakSet

WeakSet 是一种特殊的 Set

* WeakSet 的成员必须只能是对象类型的值
* WeakSet 是弱引用
垃圾回收不考虑 WeakSet，不会改变引用计数器，对象不被引用时不管 WeakSet 是否在使用都将删除
因为 WeakSet 是弱引用，不可以进行 forEach 等遍历操作
* **因为 WeakSet 是弱引用，WeakSet 没有迭代器方法和 size 属性
* 当外部引用删除时，需要自动删除数据时使用 WeakSet

什么是弱引用？ 如果其他对象都不再引用该对象，那么垃圾回收机制会自动回收该对象所占用的内存 弱引用的对象不可遍历！

**

new WeakSet(array)

* array 中的值必须是对象类型

**_desc_** WeakSet 声明定义 **params** { array } array **return** { WeakSet }

var weakSet = new WeakSet([
  { name: "zhangsan" },
  [1, 2, 3],
  function add() {}
]);
console.log(weakSet);    // WeakSet { Array(3), {...}, f }