update: --

Author: webVueBlog

README.md

@@ -13,7 +13,7 @@ https://github.com/webVueBlog/Leetcode
 
 欢迎大家前来讨论，如果觉得对你的学习有一定的帮助，欢迎点个Star （此仓库每天都会准时更新）
 
-## 🦂 阶段十五（395）
+## 🦐 阶段十五（401）
 
 <details open>
 <summary>展开查看</summary>
@@ -29,6 +29,13 @@ https://github.com/webVueBlog/Leetcode
 - 393.[DataView](./阶段十五/DataView.js)
 - 394.[ArrayBuffer 视图](./阶段十五/视图.js)
 - 395.[迭代与扩展操作](./阶段十五/迭代与扩展操作.js)
+- 396.[Map](./阶段十五/Map.js)
+- 397.[WeakMap](./阶段十五/WeakMap.js)
+- 398.[Set](./阶段十五/Set.js)
+- 399.[WeakSet](./阶段十五/WeakSet.js)
+- 400.[Map顺序与迭代](./阶段十五/Map顺序与迭代.js)
+- 401.[选择 Object 还是 Map](./阶段十五/选择.js)
+
 
 </details>
 

阶段十五/Map.js

@@ -0,0 +1,128 @@
+/**
+作为 ECMAScript 6 的新增特性，Map 是一种新的集合类型
+
+使用 new 关键字和 Map 构造函数可以创建一个空映射：
+const m = new Map();
+
+可以给 Map 构造函数传入一个可迭代对象，需要包含键/值对数组。
+
+// 使用嵌套数组初始化映射
+const m1 = new Map([ 
+ ["key1", "val1"], 
+ ["key2", "val2"], 
+ ["key3", "val3"] 
+]); 
+alert(m1.size); // 3
+
+
+// 使用自定义迭代器初始化映射
+const m2 = new Map({ 
+ [Symbol.iterator]: function*() { 
+ yield ["key1", "val1"]; 
+ yield ["key2", "val2"]; 
+ yield ["key3", "val3"]; 
+ } 
+}); 
+alert(m2.size); // 3
+
+
+// 映射期待的键/值对，无论是否提供
+const m3 = new Map([[]]); 
+alert(m3.has(undefined)); // true 
+alert(m3.get(undefined)); // undefined
+
+
+可以使用 set()方法再添加键/值对
+
+get()和 has()进行查询
+
+可以使用 delete()和 clear()删除值
+
+const m = new Map(); 
+
+alert(m.has("firstName")); // false 
+alert(m.get("firstName")); // undefined 
+alert(m.size); // 0 
+
+m.set("firstName", "Matt") 
+ .set("lastName", "Frisbie"); 
+
+alert(m.has("firstName")); // true 
+alert(m.get("firstName")); // Matt 
+alert(m.size); // 2 
+
+m.delete("firstName"); // 只删除这一个键/值对
+
+alert(m.has("firstName")); // false 
+alert(m.has("lastName")); // true 
+alert(m.size); // 1 
+
+m.clear(); // 清除这个映射实例中的所有键/值对
+
+alert(m.has("firstName")); // false 
+alert(m.has("lastName")); // false 
+alert(m.size); // 0
+
+
+*/
+
+// Object 只能使用数值、字符串或符号作为键
+
+/**
+
+const m = new Map(); 
+
+const functionKey = function() {}; 
+const symbolKey = Symbol(); 
+const objectKey = new Object(); 
+
+m.set(functionKey, "functionValue"); 
+m.set(symbolKey, "symbolValue"); 
+m.set(objectKey, "objectValue"); 
+
+alert(m.get(functionKey)); // functionValue 
+alert(m.get(symbolKey)); // symbolValue 
+alert(m.get(objectKey)); // objectValue 
+
+// SameValueZero 比较意味着独立实例不冲突
+alert(m.get(function() {})); // undefined
+
+
+
+
+const m = new Map(); 
+
+const objKey = {}, 
+ objVal = {}, 
+ arrKey = [], 
+ arrVal = []; 
+
+m.set(objKey, objVal); 
+m.set(arrKey, arrVal); 
+
+objKey.foo = "foo"; 
+objVal.bar = "bar"; 
+arrKey.push("foo"); 
+arrVal.push("bar"); 
+
+console.log(m.get(objKey)); // {bar: "bar"} 
+console.log(m.get(arrKey)); // ["bar"]
+
+
+const m = new Map(); 
+
+const a = 0/"", // NaN 
+ b = 0/"", // NaN 
+ pz = +0, 
+ nz = -0;
+
+alert(a === b); // false 
+alert(pz === nz); // true 
+
+m.set(a, "foo"); 
+m.set(pz, "bar"); 
+
+alert(m.get(b)); // foo 
+alert(m.get(nz)); // bar
+
+ */

阶段十五/Map顺序与迭代.js

@@ -0,0 +1,107 @@
+/**
+Map 实例会维护键值对的插入顺序
+
+映射实例可以提供一个迭代器（Iterator），能以插入顺序生成[key, value]形式的数组。
+
+通过 entries()方法（或者 Symbol.iterator 属性，它引用 entries()）取得这个迭代器
+
+
+
+const m = new Map([ 
+ ["key1", "val1"], 
+ ["key2", "val2"], 
+ ["key3", "val3"] 
+]); 
+
+alert(m.entries === m[Symbol.iterator]); // true 
+
+for (let pair of m.entries()) { 
+ alert(pair); 
+} 
+// [key1,val1] 
+// [key2,val2] 
+// [key3,val3] 
+
+for (let pair of m[Symbol.iterator]()) { 
+ alert(pair); 
+} 
+// [key1,val1] 
+// [key2,val2] 
+// [key3,val3]
+
+
+
+因为 entries()是默认迭代器，所以可以直接对映射实例使用扩展操作
+
+const m = new Map([ 
+ ["key1", "val1"], 
+ ["key2", "val2"], 
+ ["key3", "val3"] 
+]); 
+console.log([...m]); // [[key1,val1],[key2,val2],[key3,val3]]
+
+可以调用映射的 forEach(callback, opt_thisArg)
+
+
+const m = new Map([ 
+ ["key1", "val1"], 
+ ["key2", "val2"], 
+ ["key3", "val3"] 
+]); 
+
+m.forEach((val, key) => alert(`${key} -> ${val}`)); 
+
+// key1 -> val1 
+// key2 -> val2 
+// key3 -> val3
+
+
+const m = new Map([ 
+ ["key1", "val1"], 
+ ["key2", "val2"], 
+ ["key3", "val3"] 
+]); 
+
+for (let key of m.keys()) { 
+ alert(key); 
+} 
+// key1 
+// key2 
+// key3 
+
+for (let key of m.values()) { 
+ alert(key); 
+} 
+// value1 
+// value2 
+// value3
+
+
+
+
+
+const m1 = new Map([ 
+ ["key1", "val1"] 
+]); 
+// 作为键的字符串原始值是不能修改的
+for (let key of m1.keys()) { 
+ key = "newKey"; 
+ alert(key); // newKey 
+ alert(m1.get("key1")); // val1 
+}
+
+
+const keyObj = {id: 1}; 
+const m = new Map([ 
+ [keyObj, "val1"] 
+]); 
+// 修改了作为键的对象的属性，但对象在映射内部仍然引用相同的值
+for (let key of m.keys()) { 
+ key.id = "newKey"; 
+ alert(key); // {id: "newKey"} 
+ alert(m.get(keyObj)); // val1 
+} 
+alert(keyObj); // {id: "newKey"}
+
+
+*/

阶段十五/Set.js

@@ -0,0 +1,85 @@
+/**
+
+ECMAScript 6 新增的 Set 是一种新集合类型
+
+使用 new 关键字和 Set 构造函数可以创建一个空集合：
+const m = new Set();
+
+// 使用数组初始化集合
+const s1 = new Set(["val1", "val2", "val3"]);
+
+alert(s1.size); // 3
+
+
+// 使用自定义迭代器初始化集合
+const s2 = new Set({ 
+ [Symbol.iterator]: function*() { 
+ yield "val1"; 
+ yield "val2"; 
+ yield "val3"; 
+ } 
+}); 
+alert(s2.size); // 3
+
+可以使用 add()增加值，使用 has()查询，通过 size 取得元素数量，以及使用 delete()和 clear()删除元素
+
+const s = new Set();
+
+alert(s.has("Matt")); // false 
+alert(s.size); // 0
+
+
+s.add("Matt") 
+ .add("Frisbie");
+
+alert(s.has("Matt")); // true 
+alert(s.size); // 2
+
+s.delete("Matt");
+
+alert(s.has("Matt")); // false 
+alert(s.has("Frisbie")); // true 
+alert(s.size); // 1
+
+
+s.clear(); // 销毁集合实例中的所有值
+
+alert(s.has("Matt")); // false 
+alert(s.has("Frisbie")); // false 
+alert(s.size); // 0
+
+
+const s = new Set().add("val1"); 
+s.add("val2") 
+ .add("val3"); 
+alert(s.size); // 3
+
+
+
+const s = new Set();
+
+const functionVal = function() {}; 
+const symbolVal = Symbol(); 
+const objectVal = new Object();
+
+s.add(functionVal); 
+s.add(symbolVal); 
+s.add(objectVal);
+
+alert(s.has(functionVal)); // true 
+alert(s.has(symbolVal)); // true 
+alert(s.has(objectVal)); // true
+
+
+// SameValueZero 检查意味着独立的实例不会冲突
+alert(s.has(function() {})); // false
+
+
+
+
+
+
+
+
+
+*/