es6之數據結構 set,WeakSet,mapWeakMap

{let list = new Set();list.add(1);list.add(2);list.add(1);console.log(list);  //Set(2)?{1, 2}
let arr=[1,2,3,1,2]
let list2=new Set(arr);
console.log(list2); //Set(3)?{1, 2, 3}
}

?

Set

ES6 提供了新的數據結構 Set。它類似于數組，但是成員的值都是唯一的，沒有重復的值。

Set 本身是一個構造函數，用來生成 Set 數據結構。

{let list = new Set();list.add(5);list.add(7);console.log(list.size); //2
}

Set 函數可以接受一個數組作為參數，用來初始化。

{let arr = [1,2,3,4,5];let list = new Set(arr);console.log(list.size);  //5
}

Set中重復的元素不會添加，可以用于去重

?

Set不會轉換數據類型，數字就是數字，字符串就是字符串

{let arr=[1,2,3,1,'2']let list2=new Set(arr);console.log(list2);    //Set(4) {1, 2, 3, "2"}
}

在 Set 內部，兩個NaN是相等。

let set = new Set();
let a = NaN;
let b = NaN;
set.add(a);
set.add(b);
set // Set {NaN}

兩個對象總是不相等的。

let set = new Set();set.add({});
set.size // 1

set.add({});
set.size // 2

Set 實例的屬性和方法

Set 實例的方法分為兩大類：操作方法（用于操作數據）和遍歷方法（用于遍歷成員）。

四個操作方法:

• add(value)：添加某個值，返回 Set 結構本身。
• delete(value)：刪除某個值，返回一個布爾值，表示刪除是否成功。
• has(value)：返回一個布爾值，表示該值是否為Set的成員。
• clear()：清除所有成員，沒有返回值。

{let arr=['add','delete','clear','has'];let list=new Set(arr);console.log(list.has('add')); //trueconsole.log(list.delete('add'),list); 
//true Set(3){"delete", "clear", "has"}list.clear();     //清空console.log(list);  // Set(0){}
}

?

forEach()

Set 結構的實例與數組一樣，也擁有forEach方法，用于對每個成員執行某種操作，沒有返回值。

{let arr=['add','delete','clear','has'];let list=new Set(arr);for(let key of list.keys()){console.log(key);  // add delete clear has 
  }for(let value of list.values()){console.log(value);   // add delete clear has  
  } for(let [key,value] of list.entries()){console.log(key,value);// add add delete delete clear clear has has
  }list.forEach(function(item){console.log(item);})// add delete clear has 
}

Set 結構的實例默認可遍歷，它的默認遍歷器生成函數就是它的values方法。

這意味著，可以省略values方法，直接用for...of循環遍歷 Set。

{
let set = new Set(['red', 'green', 'blue']);for (let x of set) {console.log(x);
}
// red
// green
// blue

WeakSet

WeakSet 的成員只能是對象，而不能是其他類型的值。

{let weakList=new WeakSet();let arg={};weakList.add(arg);console.log(weakList); //{{}}

}

const ws = new WeakSet();
ws.add(1)
// TypeError: Invalid value used in weak set
ws.add(Symbol())
// TypeError: invalid value used in weak set

WeakSet 可以接受一個數組或類似數組的對象作為參數。

{const a = [[1, 2], [3, 4]];
const ws = new WeakSet(a);
console.log(ws)}
//WeakSet {Array(2), Array(2)}
//__proto__:WeakSet
//[[Entries]]:Array(2)
//0:Array(2)
//value:(2) [3, 4]
//1:Array(2)
//value:(2) [1, 2]
//length:2

注意，是a數組的成員成為 WeakSet 的成員，而不是a數組本身。這意味著，數組的成員只能是對象。

{
const b = [3, 4];
const ws = new WeakSet(b);
// Uncaught TypeError: Invalid value used in weak set(…)
}

WeakSet 結構有以下三個方法。

• add(value)：添加某個值，返回 WeakSet結構本身。
• delete(value)：刪除某個值，返回一個布爾值，表示刪除是否成功。
• has(value)：返回一個布爾值，表示該值是否為WeakSet的成員。

const ws = new WeakSet();
const obj = {};
const foo = {};ws.add(window);
ws.add(obj);ws.has(window); // true
ws.has(foo);    // false

ws.delete(window);
ws.has(window);    // false

WeakSet 沒有size屬性，沒有辦法遍歷它的成員。

ws.size // undefined
ws.forEach // undefined

Map

JavaScript 的對象（Object），本質上是鍵值對的集合（Hash 結構），但是傳統上只能用字符串當作鍵。這給它的使用帶來了很大的限制.

ES6 提供了 Map 數據結構。它類似于對象，也是鍵值對的集合，但是“鍵”的范圍不限于字符串，各種類型的值（包括對象）都可以當作鍵。也就是說，Object 結構提供了“字符串—值”的對應，Map 結構提供了“值—值”的對應，是一種更完善的 Hash 結構實現。如果你需要“鍵值對”的數據結構，Map 比 Object 更合適。

const m = new Map();
const o = {p: 'Hello World'};m.set(o, 'content')
m.get(o) // "content"

m.has(o) // true
m.delete(o) // true
m.has(o) // false

Map 也可以接受一個數組作為參數。該數組的成員是一個個表示鍵值對的數組。

const map = new Map([['name', '張三'],['title', 'Author']
]);map.size // 2
map.has('name') // true
map.get('name') // "張三"
map.has('title') // true
map.get('title') // "Author"

如果對同一個鍵多次賦值，后面的值將覆蓋前面的值。

const map = new Map();
map
.set(1, 'aaa')
.set(1, 'bbb');
map.get(1) // "bbb"

實例的屬性和操作方法

（1）size 屬性

（2）set(key, value)

（3）get(key)

（4）has(key)

（5）delete(key)

（6）clear()

?

{let map = new Map();
map.set('foo', 11);
map.set('bar', 22);
map.size ;// 2
map.get('foo');//t1
map.has('boo');  //true
map.delete('foo');  //true
map.clear();
map.size // 0
}

遍歷方法

Map 結構原生提供三個遍歷器生成函數和一個遍歷方法。

• keys()：返回鍵名的遍歷器。
• values()：返回鍵值的遍歷器。
• entries()：返回所有成員的遍歷器。
• forEach()：遍歷 Map 的所有成員。

Map 結構的默認遍歷器接口（Symbol.iterator屬性），就是entries方法。

WeakMap

WeakMap結構與Map結構類似，也是用于生成鍵值對的集合。

WeakMap與Map的區別有兩點。

首先，WeakMap只接受對象作為鍵名（null除外），不接受其他類型的值作為鍵名。

其次，WeakMap的鍵名所指向的對象，不計入垃圾回收機制。

// WeakMap 可以使用 set 方法添加成員
const wm1 = new WeakMap();
const key = {foo: 1};
wm1.set(key, 2);
wm1.get(key) // 2// WeakMap 也可以接受一個數組，
// 作為構造函數的參數
const k1 = [1, 2, 3];
const k2 = [4, 5, 6];
const wm2 = new WeakMap([[k1, 'foo'], [k2, 'bar']]);
wm2.get(k2) // "bar"

WeakMap 的語法

WeakMap 與 Map 在 API 上的區別主要是兩個，

一是沒有遍歷操作（即沒有keys()、values()和entries()方法），也沒有size屬性。

二是無法清空，即不支持clear方法。因此，WeakMap只有四個方法可用：get()、set()、has()、delete()。

?