ES6 Set

Set

---

• 特点：

1. .类似于数组，没有重复的元素（唯一性）
2. 开发中用于去除重复数据 
3. key和value都是相等的

• 一个属性：size

• 四个方法：

1. add:在末尾添加数据

2. delete:删除数据

3. has:判断目标数据是否存在

4. clear:清空集合数据

key 和 value 是相等的

let set = new Set(['a', 'b', 'c']);
console.log(set.keys());        //SetIterator {"a", "b", "c"}
console.log(set.values());      //SetIterator {"a", "b", "c"}

属性：size---与数组的length类似（求数据的长度）

//创建一个数据集合
let mySet = new Set(['a', 'b', 'c']);    
console.log(mySet);         //Set(3) {"a", "b", "c"}   
console.log(mySet.size);    //3

方法：add()---在末尾添加数据

let mySet = new Set(['a', 'b', 'c']);
console.log(mySet);         //Set(3) {"a", "b", "c"}
mySet.add('d');
console.log(mySet);         //Set(4) {"a", "b", "c", "d"}
mySet.add('d').add('e');    //可以连续调用（因为add方法返回的是mySet对象）
console.log(mySet);         //Set(5) {"a", "b", "c", "d", "e"}

方法：delete()---删除某个数据

let mySet = new Set(['a', 'b', 'c']);
console.log(mySet);             //Set(3) {"a", "b", "c"}
console.log(mySet.delete('a')); //true (delete方法返回的是布尔值)
console.log(mySet);             //Set(4) {"b", "c"}

方法：has()---判断目标数据是否存在

let mySet = new Set(['a', 'b', 'c']);
console.log(mySet);             //Set(3) {"a", "b", "c"}
console.log(mySet.has('b'));    //true (has方法返回的是布尔值)
console.log(mySet.has('f'));    //false

方法：clear()---清空集合数据

let mySet = new Set(['a', 'b', 'c']);
console.log(mySet);             //Set(3) {"a", "b", "c"}
console.log(mySet.clear())      //undefined (clear方法没有返回值)
console.log(mySet);             //Set(0) {}

Set中的特殊值

Set对象存储的值总是唯一的，所以需要判断两个值是否恒等。有几个特殊值需要特殊对待：

• +0 与 -0 在存储判断唯一性的时候是恒等的，所以不重复；

• undefined 与 undefined 是恒等的，所以不重复；

• NaN 与 NaN 是不恒等的，但是在Set中只能存一个，不重复；

let set = new Set()
set.add(+0);            
console.log(set);       //Set(1) {0}
set.add(-0);
console.log(set);       //Set(1) {0}

let set = new Set();
set.add(undefined);
console.log(set);       //Set(1) {undefined}
set.add(undefined);
console.log(set);       //Set(1) {undefined}

let set = new Set();
set.add(NaN);
console.log(set);       //Set(1) {NaN}
set.add(NaN);
console.log(set);       //Set(1) {NaN}

let set = new Set();
console.log(set);           //Set(0) {}

var o = {a: 1, b: 2};
set.add(o);                 
console.log(set);           //Set(1) {{…}}

set.add({a: 1, b: 2});
console.log(set);           //Set(2) {{…}, {…}}
//这里体现了对象之间引用不同不恒等，即使值相同，Set也能存储

set.add("cezlz");
console.log(set);           //Set(3) {{…}, {…}, "cezlz"}
//这里体现了类型的多样性

类型转换

//Array 转 Set
var mySet = new Set(['a', 'b', 'c']);
console.log(mySet);     //Set(3) {"a", "b", "c"}

//用 ... 操作符，将 Set 转 Array
var myArray = [...mySet];
console.log(myArray);   //(3) ["a", "b", "c"]

//String 转 Set
var Set = new Set('hello');
console.log(Set);     //Set(4) {"h", "e", "l", "o"}
//注：Set中 toString 方法是不能将 Set 转换成 String

Set对象作用

数组去重：

var mySet = new Set([1, 2, 3, 4, 4]);
var array = [...mySet]
console.log(array);             //(4) [1, 2, 3, 4]

并集：

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

交集：

var a = new Set([1, 2, 3, 4]);
var b = new Set([3, 4, 5, 6]);
var intersect = new Set([...a].filter(x => b.has(x)));
console.log(intersect);         //Set(2) {3, 4}

差集：

var a = new Set([1, 2, 3, 4]);
var b = new Set([3, 4, 5, 6]);
var dif1 = new Set([...a].filter(x => !b.has(x)));
console.log(dif1);              //Set(2) {1, 2}

var dif2 = new Set([...b].filter(x => !a.has(x)));
console.log(dif2);              //Set(2) {5, 6}