Merge pull request #24 from liuyepiaoxiang/master

2019-7-6 10:56:31

docs/39.md

-## 32.集（`Set`）
+## 32.集合（`Set`）
 
 > 原文： [http://exploringjs.com/impatient-js/ch_sets.html](http://exploringjs.com/impatient-js/ch_sets.html)
 
 在 ES6 之前，JavaScript 没有集合的数据结构。相反，使用了两种解决方法：
 
 *   对象的键作为字符串集。
-*   数组作为任意值的集合（例如，通过`.includes()`检查元素是否在集合中）。
+*   数组作为任意值的集合（例如，通过`.includes()`检查元素是否在集合中），缺点是元素检查缓慢。
 
-ECMAScript 6 具有数据结构`Set`，适用于任意值。
+ECMAScript 6 具有数据结构`Set`，适用于任意值且具有快速执行元素检查。
 
-### 32.1。使用集合
+### 32.1. 使用集合
 
-#### 32.1.1。创建集
+#### 32.1.1. 创建集合
 
 创建集合有三种常用方法。
 
@@ -28,7 +28,7 @@ assert.equal(emptySet.size, 0);
 const set = new Set(['red', 'green', 'blue']);
 ```
 
-第三，`.add()`方法将元素添加到 Set 并且是可链接的：
+第三，`.add()`方法将元素添加到 Set 并且是可链式调用的：
 
 ```js
 const set = new Set()
@@ -37,9 +37,9 @@ const set = new Set()
 .add('blue');
 ```
 
-#### 32.1.2。添加，删除，检查包含
+#### 32.1.2. 添加，删除，检查包含
 
-`.add()`向 Set 添加元素。 `.has()`检查某个元素是否包含在一个集合中。 `.delete()`从 Set 中删除元素。
+`.add()`向 `Set` 添加元素。 `.has()`检查某个元素是否包含在一个集合中。 `.delete()`从 `Set` 中删除元素。
 
 ```js
 const set = new Set();
@@ -51,9 +51,9 @@ assert.equal(set.delete('red'), true); // there was a deletion
 assert.equal(set.has('red'), false);
 ```
 
-#### 32.1.3。确定 Set 的大小并清除它
+#### 32.1.3. 确定 Set 的大小和清除
 
-`.size`包含 Set 中的元素数。 `.clear()`删除 Set 的所有元素。
+`.size`包含 `Set` 中的元素数量。 `.clear()`删除 `Set` 的所有元素。
 
 ```js
 const set = new Set()
@@ -66,9 +66,9 @@ set.clear();
 assert.equal(set.size, 0)
 ```
 
-#### 32.1.4。迭代一组
+#### 32.1.4. 遍历集合
 
-集是可迭代的，`for-of`循环按预期工作：
+集合是可迭代的，`for-of`循环可按预期工作：
 
 ```js
 const set = new Set(['red', 'green', 'blue']);
@@ -81,18 +81,19 @@ for (const x of set) {
 // 'blue'
 ```
 
-如您所见，集合保留迭代顺序。也就是说，元素总是按照添加顺序迭代。
+如您所见，集合保留插入顺序。也就是说，元素总是按照添加顺序迭代。
 
-[Spreading（`...`）到数组](ch_arrays.html#spreading-into-arrays)可以与 iterables 一起使用，因此可以将 Set 转换为数组：
+集合是可迭代的，可以使用[展开(...)](ch_arrays.html#spreading-into-arrays)方法将其转换为`Array`。
 
 ```js
 const set = new Set(['red', 'green', 'blue']);
 const arr = [...set]; // ['red', 'green', 'blue']
 ```
 
-##### 32.1.4.1。从数组和字符串中删除重复项
+### 32.2. 使用`Set`示例
+#### 32.2.1. 从数组中删除重复项
 
-将数组转换为 Set 并返回，从数组中删除重复项：
+将数组转换为 Set 并返回，将从数组中删除重复项：
 
 ```js
 assert.deepEqual(
@@ -100,20 +101,21 @@ assert.deepEqual(
   [1, 2, 3]);
 ```
 
+#### 32.2.2 创建一个Unicode字符集合
 字符串也是可迭代的，因此可以用作`new Set()`的参数：
 
 ```js
-assert.equal(
-  [...new Set('ababccc')].join(''),
-  'abc');
+assert.deepEqual(
+  new Set('abc'),
+  new Set(['a', 'b', 'c']));
 ```
 
-### 32.2。比较 Set 元素
+### 32.3. 什么集合元素被认为是相等的？
 
-与 Maps 一样，元素与`===`类似地进行比较，但`NaN`等于它自身。
+与 `Map`的key一样，集合元素的比较类似于`===`，但`NaN`等于它自身。
 
 ```js
-> const set = new Set([NaN]);
+> const set = new Set([NaN, NaN, NaN]);
 > set.size
 1
 > set.has(NaN)
@@ -148,36 +150,17 @@ true
 2
 ```
 
-### 32.3。缺少 Set 操作
+### 32.4. 缺少的 Set 操作
 
-集合缺少几个常见操作。它们通常可通过以下方式实施：
+集合缺少几个常见操作。它们通常可通过以下方式实现：
 
-*   将集转换为数组（通过[传播（`...`）](ch_arrays.html#spreading-into-arrays)）。
-*   执行操作。
+*   将集转换为数组（通过[展开（`...`）](ch_arrays.html#spreading-into-arrays)）。
+*   对数组执行操作。
 *   将结果转换回 Set。
 
-#### 32.3.1。制图
-
-```js
-const set = new Set([1, 2, 3]);
-const mappedSet = new Set([...set].map(x => x * 2));
-
-// Convert mappedSet to an Array to check what’s inside it
-assert.deepEqual([...mappedSet], [2, 4, 6]);
-```
-
-#### 32.3.2。过滤
+#### 32.4.1. 并集(a∪b）
 
-```js
-const set = new Set([1, 2, 3, 4, 5]);
-const filteredSet = new Set([...set].filter(x => (x % 2) === 0));
-
-assert.deepEqual([...filteredSet], [2, 4]);
-```
-
-#### 32.3.3。联盟
-
-Union（`a`∪`b`）：创建一个包含 Set `a`和 Set `b`元素的 Set。
+计算两个集合a和b的并集是指创建一个新的集合，包含a和b的所有元素。
 
 ```js
 const a = new Set([1,2,3]);
@@ -188,9 +171,9 @@ const union = new Set([...a, ...b]);
 assert.deepEqual([...union], [1, 2, 3, 4]);
 ```
 
-#### 32.3.4。路口
+#### 32.4.2. 交集(a∩b)
 
-交点（`a`∩`b`）：创建一个包含 Set `a`元素的 Set，它们也在 Set `b`中。
+计算两个集合a和b的交集是指创建一个新的集合，包含同时包含在a和b中的元素。
 
 ```js
 const a = new Set([1,2,3]);
@@ -201,9 +184,9 @@ const intersection = new Set(
 assert.deepEqual([...intersection], [2, 3]);
 ```
 
-#### 32.3.5。区别
+#### 32.4.3. 差集(a\b)
 
-差值（`a` \ `b`）：创建一个包含 Set `a`中不在 Set `b`中的元素的 Set。该操作有时也称为 _ 减去 _（`-`）。
+计算两个集合a和b的差集是指创建一个新的集合，包含那些在a中而不在b中的元素。该操作又称为减法(-)。
 
 ```js
 const a = new Set([1,2,3]);
@@ -214,33 +197,56 @@ const difference = new Set(
 assert.deepEqual([...difference], [1]);
 ```
 
-### 32.4。快速参考：`Set<T>`
+#### 32.4.4. 集合映射
 
-#### 32.4.1。构造函数
+集合没有`.map()`方法。但是我们可以从Array中借用。
+
+```js
+const set = new Set([1, 2, 3]);
+const mappedSet = new Set([...set].map(x => x * 2));
+
+// Convert mappedSet to an Array to check what’s inside it
+assert.deepEqual([...mappedSet], [2, 4, 6]);
+```
+
+#### 32.4.5. 集合过滤
+
+我们不能直接使用`.filter()`操作集合，因此我们需要使用Array的相应方法。
+
+```js
+const set = new Set([1, 2, 3, 4, 5]);
+const filteredSet = new Set([...set].filter(x => (x % 2) === 0));
+
+assert.deepEqual([...filteredSet], [2, 4]);
+```
+
+### 32.5. 快速参考：`Set<T>`
+
+#### 32.5.1. 构造函数
 
 *   `new Set<T>(values?: Iterable<T>)` <sup>[ES6]</sup>
 
-    如果未提供参数`values`，则会创建一个空集。如果这样做，则迭代值将作为元素添加到 Set 中。例如：
+    如果未提供参数`values`，则会创建一个空集。如果提供`values`，则迭代值将作为元素添加到 Set 中。例如：
     
     ```js
     const set = new Set(['red', 'green', 'blue']);
     ```
 
-#### 32.4.2。 `Set<T>.prototype`：单个设置元素
+#### 32.5.2. `Set<T>.prototype`：设置单个元素
 
 *   `.add(value: T): this` <sup>[ES6]</sup>
 
-    将`value`添加到此 Set。此方法返回`this`，这意味着它可以链接。
+    将`value`添加到此 Set。此方法返回`this`，这意味着它可以链式调用。
     
     ```js
-    const set = new Set(['red', 'green']);
-    set.add('blue');
+    const set = new Set(['red']);
+    set.add('green').add('blue');
     assert.deepEqual([...set], ['red', 'green', 'blue']);
     ```
 
 *   `.delete(value: T): boolean` <sup>[ES6]</sup>
 
-    从此 Set 中删除`value`。
+    从此 Set 中删除`value`，如果删除成功返回`true`，反之返回`false`。
     
     ```js
     const set = new Set(['red', 'green', 'blue']);
@@ -250,7 +256,7 @@ assert.deepEqual([...difference], [1]);
 
 *   `.has(value: T): boolean` <sup>[ES6]</sup>
 
-    检查`value`是否在此设置中。
+    检查`value`是否在此集合中。
     
     ```js
     const set = new Set(['red', 'green']);
@@ -258,7 +264,7 @@ assert.deepEqual([...difference], [1]);
     assert.equal(set.has('blue'), false);
     ```
 
-#### 32.4.3。 `Set<T>.prototype`：所有 Set 元素
+#### 32.5.3. `Set<T>.prototype`：所有 Set 元素
 
 *   `get .size: number` <sup>[ES6]</sup>
 
@@ -280,11 +286,11 @@ assert.deepEqual([...difference], [1]);
     assert.equal(set.size, 0);
     ```
 
-#### 32.4.4。 `Set<T>.prototype`：迭代和循环
+#### 32.5.4. `Set<T>.prototype`：迭代和循环
 
 *   `.values(): Iterable<T>` <sup>[ES6]</sup>
 
-    返回此 Set 的所有元素的可迭代。
+    返回包含该 Set 的所有元素的迭代器。
     
     ```js
     const set = new Set(['red', 'green']);
@@ -312,7 +318,9 @@ assert.deepEqual([...difference], [1]);
 
 *   `.forEach(callback: (value: T, value2: T, theSet: Set<T>) => void, thisArg?: any): void` <sup>[ES6]</sup>
 
-    循环遍历此 Set 的元素，并为每个元素调用回调（第一个参数）。 `value`和`key`都设置为元素，因此该方法与`Map.prototype.forEach`的工作方式类似。如果提供了`thisArg`，则为每个呼叫设置`this`。否则，`this`设置为`undefined`。
+    循环遍历此 Set 的元素，并为每个元素调用回调（第一个参数）。 `value`和`key`都设置为当前元素，这种冗余设计是为了使该方法的回调与`Map.prototype.forEach`相同的类型签名。
+    
+    可以通过`thisArg`指定`this`的回调。否则，`this`设置为`undefined`。
     
     ```js
     const set = new Set(['red', 'green']);
@@ -322,7 +330,7 @@ assert.deepEqual([...difference], [1]);
     // 'green'
     ```
 
-#### 32.4.5。与`Map`对称
+#### 32.5.5. 与`Map`对称
 
 仅存在以下两种方法，以使 Sets 的接口类似于 Maps 的接口。处理每个 Set 元素就好像它是一个 Map 键，其键和值是元素。