摘要：返回一個布爾值，表示該值是否為的成員。清除所有成員，沒有返回值。該數(shù)組中的每一項也必須是數(shù)組，內(nèi)部數(shù)組的首個項會作為鍵，第二項則為對應(yīng)值。返回所有成員的遍歷器需要特別注意的是，的遍歷順序就是插入順序。

Js大部分歷史時期都只存在一種集合類型，也就是數(shù)組類型。數(shù)組在 JS 中的使用正如其他語言的數(shù)組一樣，但缺少更多類型的集合導(dǎo)致數(shù)組也經(jīng)常被當作隊列與棧來使用。數(shù)組只使用了數(shù)值型的索引，而如果非數(shù)值型的索引是必要的，開發(fā)者便會使用非數(shù)組的對象。這種技巧引出了非數(shù)組對象的定制實現(xiàn)，即 Set 與 Map 。

? Set結(jié)構(gòu)類似于數(shù)組，但是沒有重復(fù)結(jié)構(gòu)
? Set會自動移除重復(fù)的值，因此可以用來過濾數(shù)組中的重復(fù)結(jié)構(gòu)
? Set內(nèi)的對象是強引用

a) let set = new Set([1, 2, 3, 4]);

Set 構(gòu)造器實際上可以接收任意可迭代對象作為參數(shù)。能使用數(shù)組是因為它們默認就是可迭代的,Set與Map也是一樣，Set構(gòu)造器會使用迭代器來提取參數(shù)中的值

b) let set = new Set();

set.add(1);
set.add(2);
set.add(2);
//如果add對相同的值進行了多次調(diào)用，那么那么在第一次之后的調(diào)用實際上會被忽略
set.add(3);
set.add("3");
// Set 不會使用強制類型轉(zhuǎn)換來判斷值是否重復(fù)。這意味著 Set 可以同時包含數(shù)值 3 與 字符串 "3" ，將它們都作為相對獨立的項.
Set判斷是否重復(fù)使用了Object.is() 方法，唯一的例外是 +0 與 -0 在 Set 中被判斷為是相等的

c) 還可以向Set添加多個值相同的對象，他們不會被合并為同一項。

let set = new Set();
let key1 = {};
let key2 = {};
set.add(key1);
set.add(key2);

Set.prototype.constructor：構(gòu)造函數(shù)，默認就是Set函數(shù)。
Set.prototype.size：返回Set實例的成員總數(shù)。

Set的方法分為兩類：操作方法 和 遍歷方法

? add(value)：添加某個值，返回 Set 結(jié)構(gòu)本身。
因為返回set本身，所以可以寫成：
set.add(1).add(2).add(3)

? delete(value)：刪除某個值，返回一個布爾值，表示刪除是否成功。
set.delete(2) ; // true
? has(value)：返回一個布爾值，表示該值是否為Set的成員。
set.has(2) ; // false
? clear()：清除所有成員，沒有返回值。

forEach()：使用回調(diào)函數(shù)遍歷每個成員
es5給數(shù)組添加了forEach()方法，使得更容易處理數(shù)組中的每一項，沒有返回值
對于數(shù)組來說forEach的三個參數(shù)：
arr[].forEach(function(value,index,array){//do})
value數(shù)組中的當前項, index當前項的索引, array原始數(shù)組

但是對于Set來說：
let set2 = new Set([{"a":1}, {"b":2}]);
set2.forEach(function(value, key, ownerSet) {
console.log(ownerSet === set2);
console.log(value === key);
});
key 與 value 總是相同的，同時 ownerSet 也始終等于 set 。此代碼輸出：
true
true
true
true

如果想在回調(diào)函數(shù)中使用當前的this，還可以在forEach中傳入this作為第二個參數(shù)
let set = new Set([1, 2]);
let processor = {

output(value) {
console.log(value);

},
process(dataSet) {

dataSet.forEach(function(value) {
  this.output(value);
}, this);

}
};
processor.process(set);
本例中，在processor.process方法中的set調(diào)用了forEach方法，并傳遞了this作為第二個參數(shù)，這樣便能正確的調(diào)用到this.output()方法
或者也可以使用箭頭函數(shù)來達到相同的效果，無需傳入this，只需將上邊的process改寫成：
process(dataSet) {
dataSet.forEach((value) => this.output(value));
}
keys()、values()和entries()
keys()：返回鍵名的遍歷器
values()：返回鍵值的遍歷器
entries()：返回鍵值對的遍歷器

keys方法、values方法、entries方法返回的都是遍歷器對象，由于Set結(jié)構(gòu)沒有鍵名，只有鍵值（或者說鍵名和鍵值是同一個值），所以keys方法和values方法的行為完全一致。

let set = new Set(["red", "green", "blue"]);

for (let item of set.keys()) {
console.log(item);
}
// red
// green
// blue

for (let item of set.values()) {
console.log(item);
}
// red
// green
// blue

for (let item of set.entries()) {
console.log(item);
}
// ["red", "red"]
// ["green", "green"]
// ["blue", "blue"]

上面代碼中，entries方法返回的遍歷器，同時包括鍵名和鍵值，所以每次輸出一個數(shù)組，它的兩個成員完全相等。

Set 結(jié)構(gòu)的實例默認可遍歷，它的默認遍歷器生成函數(shù)就是它的values方法。
Set.prototype[Symbol.iterator] === Set.prototype.values
// true
這就意味著，可以省略values方法，直接用for…of循環(huán)遍歷Set
let set = new Set(["red", "green", "blue"]);

for (let x of set) {
console.log(x);
}
// red
// green
// blue

Set最經(jīng)典的應(yīng)用就是數(shù)組排重，

Set的對象通過指針指向的內(nèi)存中的地址來做比較，所以要判斷對象是否相等，只能通過遍歷去判斷，這其中包含了很多邊際情況。所以set沒有去判斷這些，只要往里面扔一個對象，那么就是一個新的元素

使用擴展運算符可以很簡單的將Set轉(zhuǎn)成數(shù)組
let set = new Set([1, 2, 3, 3, 3, 4, 5]),
let array = [...set];
console.log(array); // [1,2,3,4,5]
該示例很好的說明了Set的一個重要的功能，數(shù)組排重，當然也很好的展示了，如何從Set轉(zhuǎn)成數(shù)組的過程。
注意，這種轉(zhuǎn)變是生成了一個新的數(shù)組對象原來的Set依然存在。

如最初的構(gòu)造示例：
let set = new Set([1,4,5,6,7]);

主要寫自身特性和與Set的區(qū)別？

驗證：外部賦空看內(nèi)部是否變化？
外部回收后？

由于 Set 類型存儲對象引用的方式，它也可以被稱為 Strong Set 。對象存儲在 Set 的一個實例中時，實際上相當于把對象存儲在變量中。只要對于 Set 實例的引用仍然存在，所存儲的對象就無法被垃圾回收機制回收，從而無法釋放內(nèi)存。

當 JS 代碼在網(wǎng)頁中運行，同時你想保持與 DOM 元素的聯(lián)系，在該元素可能被其他腳本移除的情況下，你應(yīng)當不希望自己的代碼保留對該 DOM 元素的最后一個引用（這種情況被稱為內(nèi)存泄漏）
為了緩解這個問題， ES6 也包含了 Weak Set ，該類型只允許存儲對象弱引用，而不能存儲基本類型的值。對象的弱引用在它自己成為該對象的唯一引用時，不會阻止垃圾回收

WeakSet 結(jié)構(gòu)有以下三個方法。
WeakSet.prototype.add(value)：向 WeakSet 實例添加一個新成員。
WeakSet.prototype.delete(value)：清除 WeakSet 實例的指定成員。
WeakSet.prototype.has(value)：返回一個布爾值，表示某個值是否在 WeakSet 實例之中。

對于 WeakSet 的實例，若調(diào)用 add() 方法時傳入了非對象的參數(shù)，就會拋出錯誤（

has() 或 delete() 則會在傳入了非對象的參數(shù)時返回 false ）；

Weak Set 不可迭代，因此不能被用在 for-of 循環(huán)中；

Weak Set 無法暴露出任何迭代器（例如 keys() 與 values() 方法），因此沒有任何編

程手段可用于判斷 Weak Set 的內(nèi)容；

Weak Set 沒有 forEach() 方法；

Weak Set 沒有 size 屬性。

WeakSet之所以不可遍歷是由于 WeakSet 內(nèi)部有多少個成員，取決于垃圾回收機制有沒有運行，運行前后很可能成員個數(shù)是不一樣的，而垃圾回收機制何時運行是不可預(yù)測的，因此 ES6 規(guī)定 WeakSet 不可遍歷。
WeakSet常用場景
Weak Set 看起來功能有限，而這對于正確管理內(nèi)存而言是必要的。一般來說，若只想追蹤對象的引用，應(yīng)當使用 Weak Set 而不是正規(guī) Set
如果Set中引用了不再需要的大型對象，如已經(jīng)從DOM樹中刪除的DOM元素，那么其回收代價是昂貴的

JavaScript 的對象（Object），本質(zhì)上是鍵值對的集合（Hash 結(jié)構(gòu)），但是傳統(tǒng)上只能用字符串當作鍵。這給它的使用帶來了很大的限制。
為了解決這個問題，ES6 提供了 Map 數(shù)據(jù)結(jié)構(gòu)。它類似于對象，也是鍵值對的集合，但是“鍵”的范圍不限于字符串，各種類型的值（包括對象）都可以當作鍵。也就是說，Object 結(jié)構(gòu)提供了“字符串—值”的對應(yīng)，Map 結(jié)構(gòu)提供了“值—值”的對應(yīng)，是一種更完善的 Hash 結(jié)構(gòu)實現(xiàn)。如果你需要“鍵值對”的數(shù)據(jù)結(jié)構(gòu)，Map 比 Object 更合適。

ES6 的 Map 類型是鍵值對的有序列表，而鍵和值都可以是任意類型。鍵的比較使用的是Object.is() ，因此你能將 5 與 "5" 同時作為鍵，因為它們類型不同。這與使用對象屬性
作為鍵的方式（指的是用對象來模擬 Map ）截然不同，因為對象的屬性會被強制轉(zhuǎn)換為字符串。

你可以調(diào)用 set() 方法并給它傳遞一個鍵與一個關(guān)聯(lián)的值，來給 Map 添加項；此后使用鍵名來調(diào)用 get() 方法便能提取對應(yīng)的值。例如：
let map = new Map();
map.set("title", "Understanding ES6");
map.set("year", 2016);
console.log(map.get("title")); // "Understanding ES6"
console.log(map.get("year")); // 2016

依然與 Set 類似，你能將數(shù)組傳遞給 Map 構(gòu)造器，以便使用數(shù)據(jù)來初始化一個 Map 。該數(shù)組中的每一項也必須是數(shù)組，內(nèi)部數(shù)組的首個項會作為鍵，第二項則為對應(yīng)值。因此整個Map 就被這些雙項數(shù)組所填充。例如：
let map = new Map([["name", "Nicholas"], ["age", 25]]);
console.log(map.has("name")); // true
console.log(map.get("name")); // "Nicholas"
console.log(map.size); // 2
通過構(gòu)造器中的初始化， "name" 與 "age" 這兩個鍵就被添加到 map 變量中。雖然由數(shù)組構(gòu)成的數(shù)組看起來有點奇怪，這對于準確表示鍵來說卻是必要的：因為鍵允許是任意數(shù)據(jù)類型，將鍵存儲在數(shù)組中，是確保它們在被添加到 Map 之前不會被強制轉(zhuǎn)換為其他類型的唯一方法。
Map構(gòu)造函數(shù)接受數(shù)組作為參數(shù)，實際上執(zhí)行的是下面的算法。
const items = [
["name", "Nicholas"]
["age", 25] ]

const map = new Map();

items.forEach(

([key, value]) => map.set(key, value)

);

事實上，不僅僅是數(shù)組，任何具有 Iterator 接口、且每個成員都是一個雙元素的數(shù)組的數(shù)據(jù)結(jié)構(gòu)都可以當做Map構(gòu)造函數(shù)的參數(shù)。這就是說，Set和Map都可以用來生成新的Map

const set = new Set([
["foo", 1],
["bar", 2]
]);
const m1 = new Map(set);
m1.get("foo") // 1

const m2 = new Map([["baz", 3]]);
const m3 = new Map(m2);
m3.get("baz") // 3
上面代碼中，我們分別使用 Set 對象和 Map 對象，當作Map構(gòu)造函數(shù)的參數(shù)，結(jié)果都生成了新的 Map 對象。

Map 同樣擁有 size 屬性，用于指明包含了多少個鍵值對。以下代碼用不同方式使用了這三種方法以及 size 屬性：

2.11、set(key, value)

set方法設(shè)置鍵名key對應(yīng)的鍵值為value，然后返回整個 Map 結(jié)構(gòu)。如果key已經(jīng)有值，則鍵值會被更新，否則就新生成該鍵。
const m = new Map();
m.set("edition", 6) // 鍵是字符串
m.set(262, "standard") // 鍵是數(shù)值
m.set(undefined, "nah") // 鍵是 undefined
set方法返回的是當前的Map對象，因此可以采用鏈式寫法。
let map = new Map()
.set(1, "a")
.set(2, "b")
.set(3, "c");

2.12、get(key)

get方法讀取key對應(yīng)的鍵值，如果找不到key，返回undefined。
const m = new Map();
const hello = function() {console.log("hello");};
m.set(hello, "Hello ES6!") // 鍵是函數(shù)

m.get(hello) // Hello ES6!

Map 與 Set 共享了幾個方法，這是有意的，允許你使用相似的方式來與 Map 及 Set 進行交互。以下三個方法在 Map 與 Set 上都存在：

2.13.1、has(key)

has方法返回一個布爾值，表示某個鍵是否在當前 Map 對象之中。
const m = new Map();
m.set("edition", 6);
m.set(262, "standard");
m.set(undefined, "nah");
m.has("edition") // true
m.has("years") // false
m.has(262) // true
m.has(undefined) // true

2.13.2、delete(key)

delete方法刪除某個鍵，返回true。如果刪除失敗，返回false。
const m = new Map();
m.set(undefined, "nah");
m.has(undefined) // true

m.delete(undefined)
m.has(undefined) // false

2.13.4、clear()

clear方法清除所有成員，沒有返回值。
let map = new Map();
map.set("foo", true);
map.set("bar", false);

map.size // 2
map.clear()
map.size // 0

? keys()：返回鍵名的遍歷器。
? values()：返回鍵值的遍歷器。
? entries()：返回所有成員的遍歷器
需要特別注意的是，Map 的遍歷順序就是插入順序。
const map = new Map([
["F", "no"],
["T", "yes"],
]);

for (let key of map.keys()) {
console.log(key);
}
// "F"
// "T"

for (let value of map.values()) {
console.log(value);
}
// "no"
// "yes"

for (let item of map.entries()) {
console.log(item[0], item[1]);
}
// "F" "no"
// "T" "yes"

// 或者
for (let [key, value] of map.entries()) {
console.log(key, value);
}
// "F" "no"
// "T" "yes"

// 等同于使用map.entries()
for (let [key, value] of map) {
console.log(key, value);
}
// "F" "no"
// "T" "yes"
上面代碼最后的那個例子，表示 Map 結(jié)構(gòu)的默認遍歷器接口（Symbol.iterator屬性），就是entries方法。

Map 的 forEach() 方法類似于 Set 與數(shù)組的同名方法，它接受一個能接收三個參數(shù)的回調(diào)函數(shù)：

Map 中下個位置的值；

該值所對應(yīng)的鍵；

目標 Map 自身。

回調(diào)函數(shù)的這些參數(shù)更緊密契合了數(shù)組 forEach() 方法的行為，即：第一個參數(shù)是值、第二個參數(shù)則是鍵（數(shù)組中的鍵是數(shù)值索引）。此處有個示例：
let map = new Map([
["name", "Nicholas"],
["age", 25]
]);
map.forEach(function(value, key, ownerMap) {
console.log(key + " " + value);
console.log(ownerMap === map);
});
forEach() 的回調(diào)函數(shù)輸出了傳給它的信息。其中 value 與 key 被直接輸出， ownerMap
與 map 進行了比較，說明它們是相等的。這就輸出了：
name Nicholas
true
age 25
true

Map 結(jié)構(gòu)轉(zhuǎn)為數(shù)組結(jié)構(gòu)，比較快速的方法是使用擴展運算符（...）。
const map = new Map([
[1, "one"],
[2, "two"],
[3, "three"],
]);
[...map.keys()]
// [1, 2, 3]
[...map.values()]
// ["one", "two", "three"]
[...map.entries()]
// [[1,"one"], [2, "two"], [3, "three"]]
[...map]
// [[1,"one"], [2, "two"], [3, "three"]]

將數(shù)組傳入 Map 構(gòu)造函數(shù)，就可以轉(zhuǎn)為 Map。
new Map([
[true, 7],
[{foo: 3}, ["abc"]]
])
// Map {
// true => 7,
// Object {foo: 3} => ["abc"]
// }

如果所有 Map 的鍵都是字符串，它可以無損地轉(zhuǎn)為對象。
function strMapToObj(strMap) {
let obj = Object.create(null);
for (let [k,v] of strMap) {

obj[k] = v;

}
return obj;
}

const myMap = new Map()
.set("yes", true)
.set("no", false);
strMapToObj(myMap)
// { yes: true, no: false }
如果有非字符串的鍵名，那么這個鍵名會被轉(zhuǎn)成字符串，再作為對象的鍵名。

function objToStrMap(obj) {
let strMap = new Map();
for (let k of Object.keys(obj)) {

strMap.set(k, obj[k]);

}
return strMap;
}

objToStrMap({yes: true, no: false})
// Map {"yes" => true, "no" => false}

Map 轉(zhuǎn)為 JSON 要區(qū)分兩種情況。一種情況是，Map 的鍵名都是字符串，這時可以選擇轉(zhuǎn)為對象 JSON。
function strMapToJson(strMap) {
return JSON.stringify(strMapToObj(strMap));
}

let myMap = new Map().set("yes", true).set("no", false);
strMapToJson(myMap)
// "{"yes":true,"no":false}"
另一種情況是，Map 的鍵名有非字符串，這時可以選擇轉(zhuǎn)為數(shù)組 JSON。
function mapToArrayJson(map) {
return JSON.stringify([...map]);
}

let myMap = new Map().set(true, 7).set({foo: 3}, ["abc"]);
mapToArrayJson(myMap)
// "[[true,7],[{"foo":3},["abc"]]]"

JSON 轉(zhuǎn)為 Map，正常情況下，所有鍵名都是字符串。
function jsonToStrMap(jsonStr) {
return objToStrMap(JSON.parse(jsonStr));
}

jsonToStrMap("{"yes": true, "no": false}")
// Map {"yes" => true, "no" => false}
但是，有一種特殊情況，整個 JSON 就是一個數(shù)組，且每個數(shù)組成員本身，又是一個有兩個成員的數(shù)組。這時，它可以一一對應(yīng)地轉(zhuǎn)為 Map。這往往是 Map 轉(zhuǎn)為數(shù)組 JSON 的逆操作。
function jsonToMap(jsonStr) {
return new Map(JSON.parse(jsonStr));
}

jsonToMap("[[true,7],[{"foo":3},["abc"]]]")
// Map {true => 7, Object {foo: 3} => ["abc"]}

WeakMap與Map的區(qū)別有兩點。
首先，WeakMap只接受對象作為鍵名（null除外），不接受其他類型的值作為鍵名。
const map = new WeakMap();
map.set(1, 2)
// TypeError: 1 is not an object!
map.set(Symbol(), 2)
// TypeError: Invalid value used as weak map key
map.set(null, 2)
// TypeError: Invalid value used as weak map key
其次，WeakMap的鍵名所指向的對象，不計入垃圾回收機制。
WeakMap的設(shè)計目的在于，有時我們想在某個對象上面存放一些數(shù)據(jù)，但是這會形成對于這個對象的引用。請看下面的例子。
const e1 = document.getElementById("foo");
const e2 = document.getElementById("bar");
const arr = [
[e1, "foo 元素"],
[e2, "bar 元素"],
];
上面代碼中，e1和e2是兩個對象，我們通過arr數(shù)組對這兩個對象添加一些文字說明。這就形成了arr對e1和e2的引用。
一旦不再需要這兩個對象，我們就必須手動刪除這個引用，否則垃圾回收機制就不會釋放e1和e2占用的內(nèi)存。
// 不需要 e1 和 e2 的時候
// 必須手動刪除引用
arr [0] = null;
arr [1] = null;
上面這樣的寫法顯然很不方便。一旦忘了寫，就會造成內(nèi)存泄露。
WeakMap 就是為了解決這個問題而誕生的，它的鍵名所引用的對象都是弱引用，即垃圾回收機制不將該引用考慮在內(nèi)。因此，只要所引用的對象的其他引用都被清除，垃圾回收機制就會釋放該對象所占用的內(nèi)存。也就是說，一旦不再需要，WeakMap 里面的鍵名對象和所對應(yīng)的鍵值對會自動消失，不用手動刪除引用。

ES6 的 WeakMap 類型是鍵值對的無序列表，其中鍵必須是非空的對象，值則允許是任意類型。 WeakMap 的接口與 Map 的非常相似
// WeakMap 可以使用 set 方法添加成員
const wm1 = new WeakMap();
const key = {foo: 1};
wm1.set(key, 2);
wm1.get(key) // 2

// WeakMap 也可以接受一個數(shù)組，
// 作為構(gòu)造函數(shù)的參數(shù)
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 上的區(qū)別主要是兩個，一是沒有遍歷操作（即沒有keys()、values()和entries()方法），也沒有size屬性。因為沒有辦法列出所有鍵名，某個鍵名是否存在完全不可預(yù)測，跟垃圾回收機制是否運行相關(guān)。這一刻可以取到鍵名，下一刻垃圾回收機制突然運行了，這個鍵名就沒了，為了防止出現(xiàn)不確定性，就統(tǒng)一規(guī)定不能取到鍵名。二是無法清空，即不支持clear方法。因此，WeakMap只有四個方法可用：get()、set()、has()、delete()。
const wm = new WeakMap();
// size、forEach、clear 方法都不存在
wm.size // undefined
wm.forEach // undefined
wm.clear // undefined

Weak Map 的最佳用武之地，就是在瀏覽器中創(chuàng)建一個關(guān)聯(lián)到特定 DOM 元素的對象。例如，某些用在網(wǎng)頁上的 JS 庫會維護一個自定義對象，用于引用該庫所使用的每一個 DOM 元素，并且其映射關(guān)系會存儲在內(nèi)部的對象緩存中。
該方法的困難之處在于：如何判斷一個 DOM 元素已不復(fù)存在于網(wǎng)頁中，以便該庫能移除此元素的關(guān)聯(lián)對象。若做不到，該庫就會繼續(xù)保持對 DOM 元素的一個無效引用，并造成內(nèi)存泄漏。使用 Weak Map 來追蹤 DOM 元素，依然允許將自定義對象關(guān)聯(lián)到每個 DOM 元素，而在此對象所關(guān)聯(lián)的 DOM 元素不復(fù)存在時，它就會在 Weak Map 中被自動銷毀。
必須注意的是， Weak Map 的鍵才是弱引用，而值不是。在 Weak Map 的值中存儲對象會阻止垃圾回收，即使該對象的其他引用已全都被移除。

當決定是要使用 Weak Map 還是使用正規(guī) Map 時，首要考慮因素在于你是否只想使用對象類型的鍵。如果你打算這么做，那么最好的選擇就是 Weak Map 。因為它能確保額外數(shù)據(jù)在不再可用后被銷毀，從而能優(yōu)化內(nèi)存使用并規(guī)避內(nèi)存泄漏。
要記住 Weak Map 只為它們的內(nèi)容提供了很小的可見度，因此你不能使用 forEach() 方法、size 屬性或 clear() 方法來管理其中的項。如果你確實需要一些檢測功能，那么正規(guī) Map會是更好的選擇，只是一定要確保留意內(nèi)存的使用。

//map和set 比較的方法是不是一樣
NaN 和 +0 -0