Commit 4fe4539

Object.assign(undefined); // 报错

ES6之后，JavaScript一共有 7 种数据类型：`Symbol`、`undefined`、`null`、`Boolean`、`String`、`Number`、`Object`。

* **6.Symbol.search**

ES6 新增内置对象的Symbol.toStringTag属性值如下。

- JSON[Symbol.toStringTag]：'JSON'

- Math[Symbol.toStringTag]：'Math'

- Module 对象M[Symbol.toStringTag]：'Module'

- ArrayBuffer.prototype[Symbol.toStringTag]：'ArrayBuffer'

- DataView.prototype[Symbol.toStringTag]：'DataView'

- Map.prototype[Symbol.toStringTag]：'Map'

- Promise.prototype[Symbol.toStringTag]：'Promise'

- Set.prototype[Symbol.toStringTag]：'Set'

- %TypedArray%.prototype[Symbol.toStringTag]：'Uint8Array'等

- WeakMap.prototype[Symbol.toStringTag]：'WeakMap'

- WeakSet.prototype[Symbol.toStringTag]：'WeakSet'

- %MapIteratorPrototype%[Symbol.toStringTag]：'Map Iterator'

- %SetIteratorPrototype%[Symbol.toStringTag]：'Set Iterator'

- %StringIteratorPrototype%[Symbol.toStringTag]：'String Iterator'

- Symbol.prototype[Symbol.toStringTag]：'Symbol'

- Generator.prototype[Symbol.toStringTag]：'Generator'

- GeneratorFunction.prototype[Symbol.toStringTag]：'GeneratorFunction'

与 Set 类型，都是表示不重复的值的集合，但是区别如下：

1. WeakSet 成员只能为对象，不能为其他类型的值：

const leo = new WeakSet();

leo.add(1); // TypeError: Invalid value used in weak set

leo.add(Symbol()); // TypeError: Invalid value used in weak set

2. WeakSet 成员对象为弱引用

垃圾回收机制不考虑 WeakSet 对该对象对引用，即如果其他对象不再引用该对象，那么就会被垃圾回收机制自动回收。

3. WeakSet 对象没有 `size` 属性，是不可枚举的，无法获取集合的大小。

WeakSet 是一个构造函数，可以使用 `new` 命令，创建 WeakSet 数据结构。

const leo = new WeakSet();

WeakSet 可以接受一个**数组**或**类数组对象**作为参数。该数组的所有成员，都会自动成为 WeakSet 实例对象的成员。

实际上，任何具有 Iterable 接口的对象，都可以作为 WeakSet 的参数。

const arr = [[1, 2], [3, 4]];

const leo = new WeakSet(arr);

上面代码中，`arr` 是一个**数组**，它有两个成员，也都是数组。`arr` 作为 WeakSet 构造函数的参数，`arr` 的成员会自动成为 WeakSet 的成员。

注意，是 `arr` 数组的成员成为 WeakSet 的成员，而不是 `arr` 数组本身。这意味着，**数组的成员只能是对象**。

const arr = [3, 4];

const leo = new WeakSet(arr);

上面代码中，数组 `arr` 的成员不是对象，加入 WeakSet 就会**报错**。

WeakSet 结构有以下三个方法。

- `WeakSet.prototype.add(value)`：向 WeakSet 实例添加一个新成员。

- `WeakSet.prototype.delete(value)`：清除 WeakSet 实例的指定成员。

- `WeakSet.prototype.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

ws.forEach(function(item){ console.log('WeakSet has ' + item)})

上面代码试图获取 `size` 和 `forEach` 属性，结果都不能成功。

WeakSet 不能遍历，是因为成员都是弱引用，随时可能消失，遍历机制无法保证成员的存在，很可能刚刚遍历结束，成员就取不到了。WeakSet 的一个用处，是储存 DOM 节点，而不用担心这些节点从文档移除时，会引发内存泄漏。

下面是 WeakSet 的另一个例子。

const foos = new WeakSet()

class Foo {

constructor() {

foos.add(this)

}

method () {

if (!foos.has(this)) {

throw new TypeError('Foo.prototype.method 只能在Foo的实例上调用！');

}

}

}

上面代码保证了 `Foo` 的实例方法，只能在 `Foo` 的实例上调用。这里使用 WeakSet 的好处是，`foos` 对实例的引用，不会被计入内存回收机制，所以删除实例的时候，不用考虑 `foos`，也不会出现内存泄漏。

WeakMap 结构与 Map 结构类似，也是用于**生成键值对的集合**。

const wm1 = new WeakMap();

const key = {foo: 1};

wm1.set(key, 2);

wm1.get(key) // 2

const k1 = [1, 2, 3];

const k2 = [4, 5, 6];

const wm2 = new WeakMap([[k1, 'foo'], [k2, 'bar']]);

wm2.get(k2) // "bar"

WeakMap 与 Map 的区别有两点:

1. WeakMap 只接受对象作为键名（null除外），不接受其他类型的值作为键名。

const map = new WeakMap();

map.set(1, 2)

map.set(Symbol(), 2)

map.set(null, 2)

2. WeakMap 的键名所指向的对象，不计入垃圾回收机制。

WeakMap 的设计目的在于，有时我们想在某个对象上面存放一些数据，但是这会形成对于这个对象的引用。请看下面的例子。

const e1 = document.getElementById('foo');

const e2 = document.getElementById('bar');

const arr = [

[e1, 'foo 元素'],

[e2, 'bar 元素'],

];

上面代码中，e1和e2是两个对象，我们通过arr数组对这两个对象添加一些文字说明。这就形成了arr对e1和e2的引用。

一旦不再需要这两个对象，我们就必须手动删除这个引用，否则垃圾回收机制就不会释放e1和e2占用的内存。

arr [0] = null;

arr [1] = null;

上面这样的写法显然很不方便。一旦忘了写，就会造成内存泄露。

WeakMap 就是为了解决这个问题而诞生的，它的键名所引用的对象都是弱引用，即垃圾回收机制不将该引用考虑在内。因此，只要所引用的对象的其他引用都被清除，垃圾回收机制就会释放该对象所占用的内存。也就是说，一旦不再需要，WeakMap 里面的键名对象和所对应的键值对会自动消失，不用手动删除引用。

基本上，如果你要往对象上添加数据，又不想干扰垃圾回收机制，就可以使用 WeakMap。一个典型应用场景是，在网页的 DOM 元素上添加数据，就可以使用WeakMap结构。当该 DOM 元素被清除，其所对应的WeakMap记录就会自动被移除。

const wm = new WeakMap();

const element = document.getElementById('example');

wm.set(element, 'some information');

wm.get(element) // "some information"

上面代码中，先新建一个 Weakmap 实例。然后，将一个 DOM 节点作为键名存入该实例，并将一些附加信息作为键值，一起存放在 WeakMap 里面。这时，WeakMap 里面对element的引用就是弱引用，不会被计入垃圾回收机制。

也就是说，上面的 DOM 节点对象的引用计数是1，而不是2。这时，一旦消除对该节点的引用，它占用的内存就会被垃圾回收机制释放。Weakmap 保存的这个键值对，也会自动消失。

总之，WeakMap的专用场合就是，它的键所对应的对象，可能会在将来消失。WeakMap结构有助于防止内存泄漏。

注意，WeakMap 弱引用的只是键名，而不是键值。键值依然是正常引用。

const wm = new WeakMap();

let key = {};

let obj = {foo: 1};

wm.set(key, obj);

obj = null;

wm.get(key)

上面代码中，键值obj是正常引用。所以，即使在 WeakMap 外部消除了obj的引用，WeakMap 内部的引用依然存在。

3. WeakMap 没有遍历操作对 API。

WeakMap 是没有遍历操作（即没有`keys()`、`values()`和e`ntries()`方法），也没有`size`属性。

因为没有办法列出所有键名，某个键名是否存在完全不可预测，跟垃圾回收机制是否运行相关。这一刻可以取到键名，下一刻垃圾回收机制突然运行了，这个键名就没了，为了防止出现不确定性，就统一规定不能取到键名。

const wm = new WeakMap();

wm.size // undefined

wm.forEach // undefined

4. WeakMap 无法清空。

即不支持 `clear`方法。

因此，WeakMap 只有四个方法可用：`get()`、`set()`、`has()`、`delete()`。

const wm = new WeakMap();

wm.clear // undefined

**WeakMap 应用**：

**场景1：当我们想要为DOM添加数据时，可使用 `WeakMap` 。**

好处在于，当DOM元素移除时，对应 WeakMap 记录也会自动移除：

<div id="WeakMap"></div>

const wm = new WeakMap();

const weakMap = document.getElementById('WeakMap');

wm.set(weakMap, 'some information');

wm.get(weakMap) //"some information"

**场景2：当我们想要为DOM元素添加事件监听时，可使用 `WeakMap` 。**

<button id="button1">按钮1</button>

<button id="button2">按钮2</button>

const button1 = document.getElementById('button1');

const button2 = document.getElementById('button2');

const handler1 = () => { console.log("button1 被点击") };

const handler2 = () => { console.log("button2 被点击") };

button1.addEventListener('click', handler1, false);

button2.addEventListener('click', handler2, false);

const listener = new WeakMap();

listener.set(button1, handler1);

listener.set(button2, handler2);

button1.addEventListener('click', listener.get(button1), false);

button2.addEventListener('click', listener.get(button2), false);

代码2比起代码1的好处是：由于监听函数是放在 WeakMap 里面，

则一旦 DOM 对象button1 / button2消失，与它绑定的监听函数handler1和handler2 也会自动消失。