Skip to content

Commit bd618e2

Browse files
levidingleviding
committed
feat: update translation to 2022-02-03
1 parent e030f03 commit bd618e2

16 files changed

Lines changed: 124 additions & 89 deletions

File tree

‎1-js/05-data-types/07-map-set/article.md‎

Lines changed: 12 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,10 @@
11

22
# Map and Set（映射和集合）
33

4-
我们已经了解了以下复杂的数据结构：
4+
学到现在，我们已经了解了以下复杂的数据结构：
55

6-
- 存储带键的数据（keyed）集合的对象。
7-
- 存储有序集合的数组。
6+
- 对象，存储带有键的数据的集合。
7+
- 数组，存储有序集合。
88

99
但这还不足以应对现实情况。这就是为什么存在 `Map` 和 `Set`。
1010

@@ -42,7 +42,7 @@ alert( map.size ); // 3
4242
如我们所见，与对象不同，键不会被转换成字符串。键可以是任何类型。
4343

4444
```smart header="`map[key]` 不是使用 `Map` 的正确方式"
45-
虽然 `map[key]` 也有效，例如我们可以设置 `map[key] = 2`，这样会将 `map` 视为 JavaScript 的 plain object，因此它暗含了所有相应的限制（没有对象键等）。
45+
虽然 `map[key]` 也有效，例如我们可以设置 `map[key] = 2`，这样会将 `map` 视为 JavaScript 的 plain object，因此它暗含了所有相应的限制（仅支持 string/symbol 键等）。
4646

4747
所以我们应该使用 `map` 方法：`set` 和 `get` 等。
4848
```
@@ -63,24 +63,26 @@ visitsCountMap.set(john, 123);
6363
alert( visitsCountMap.get(john) ); // 123
6464
```
6565

66-
使用对象作为键是 `Map` 最值得注意和重要的功能之一。对于字符串键，`Object`（普通对象）也能正常使用，但对于对象键则不行。
66+
使用对象作为键是 `Map` 最值得注意和重要的功能之一。在 `Object` 中，我们则无法使用对象作为键。在 `Object` 中使用字符串作为键是可以的，但我们无法使用另一个 `Object` 作为 `Object` 中的键。
6767

6868
我们来尝试一下：
6969

7070
```js run
7171
let john = { name: "John" };
72+
let ben = { name: "Ben" };
7273

7374
let visitsCountObj = {}; // 尝试使用对象
7475

75-
visitsCountObj[john] = 123; // 尝试将 john 对象作为键
76+
visitsCountObj[ben] = 234; // 尝试将对象 ben 用作键
77+
visitsCountObj[john] = 123; // 尝试将对象 john 用作键，但我们会发现使用对象 ben 作为键存下的值会被替换掉
7678

7779
*!*
78-
// 是写成了这样!
80+
// 变成这样了！
7981
alert( visitsCountObj["[object Object]"] ); // 123
8082
*/!*
8183
```
8284

83-
因为 `visitsCountObj` 是一个对象，它会将所有的键如 `john` 转换为字符串，所以我们得到字符串键 `"[object Object]"`。这显然不是我们想要的结果。
85+
因为 `visitsCountObj` 是一个对象，它会将所有 `Object` 键例如上面的 `john` 和 `ben` 转换为字符串 `"[object Object]"`。这显然不是我们想要的结果。
8486

8587
```smart header="`Map` 是怎么比较键的？"
8688
`Map` 使用 [SameValueZero](https://tc39.github.io/ecma262/#sec-samevaluezero) 算法来比较键是否相等。它和严格等于 `===` 差不多，但区别是 `NaN` 被看成是等于 `NaN`。所以 `NaN` 也可以被用作键。
@@ -304,10 +306,10 @@ set.forEach((value, valueAgain, set) => {
304306
方法和属性如下：
305307
306308
- `new Map([iterable])` —— 创建 map，可选择带有 `[key,value]` 对的 `iterable`（例如数组）来进行初始化。
307-
- `map.set(key, value)` —— 根据键存储值。
309+
- `map.set(key, value)` —— 根据键存储值，返回 map 自身。
308310
- `map.get(key)` —— 根据键来返回值，如果 `map` 中不存在对应的 `key`，则返回 `undefined`。
309311
- `map.has(key)` —— 如果 `key` 存在则返回 `true`，否则返回 `false`。
310-
- `map.delete(key)` —— 删除指定键的值。
312+
- `map.delete(key)` —— 删除指定键对应的值，如果在调用时 `key` 存在，则返回 `true`，否则返回 `false`。
311313
- `map.clear()` —— 清空 map 。
312314
- `map.size` —— 返回当前元素个数。
313315

‎1-js/05-data-types/08-weakmap-weakset/article.md‎

Lines changed: 12 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,8 @@
11
# WeakMap and WeakSet（弱映射和弱集合）
22

3-
我们从前面的 <info:garbage-collection> 章节中知道，JavaScript 引擎在值可访问（并可能被使用）时将其存储在内存中。
3+
我们从前面的 <info:garbage-collection> 章节中知道，JavaScript 引擎在值“可达”和可能被使用时会将其保持在内存中。
44

5-
例如:
5+
例如：
66
```js
77
let john = { name: "John" };
88

@@ -16,7 +16,7 @@ john = null;
1616
*/!*
1717
```
1818

19-
通常，当对象、数组这类数据结构在内存中时，它们的子元素，如对象的属性、数组的元素都是可以访问的。
19+
通常，当对象、数组之类的数据结构在内存中时，它们的子元素，如对象的属性、数组的元素都被认为是可达的。
2020

2121
例如，如果把一个对象放入到数组中，那么只要这个数组存在，那么这个对象也就存在，即使没有其他对该对象的引用。
2222

@@ -32,6 +32,7 @@ john = null; // 覆盖引用
3232
*!*
3333
// 前面由 john 所引用的那个对象被存储在了 array 中
3434
// 所以它不会被垃圾回收机制回收
35+
// 我们可以通过 array[0] 获取到它
3536
*/!*
3637
```
3738

@@ -146,7 +147,7 @@ countUser(john); // count his visits
146147
john = null;
147148
```
148149

149-
现在 `john` 这个对象应该被垃圾回收，但他仍在内存中，因为它是 `visitsCountMap` 中的一个键。
150+
现在，`john` 这个对象应该被垃圾回收，但它仍在内存中，因为它是 `visitsCountMap` 中的一个键。
150151

151152
当我们移除用户时，我们需要清理 `visitsCountMap`，否则它将在内存中无限增大。在复杂的架构中，这种清理会成为一项繁重的任务。
152153

@@ -163,13 +164,13 @@ function countUser(user) {
163164
}
164165
```
165166

166-
现在我们不需要去清理 `visitsCountMap` 了。当 `john` 对象变成不可访问时，即便它是 `WeakMap` 里的一个键，它也会连同它作为 `WeakMap` 里的键所对应的信息一同被从内存中删除。
167+
现在我们不需要去清理 `visitsCountMap` 了。当 `john` 对象变成不可达时，即便它是 `WeakMap` 里的一个键，它也会连同它作为 `WeakMap` 里的键所对应的信息一同被从内存中删除。
167168

168169
## 使用案例：缓存
169170

170-
另外一个普遍的例子是缓存：当一个函数的结果需要被记住（“缓存”），这样在后续的对同一个对象的调用时，就可以重用这个被缓存的结果。
171+
另外一个常见的例子是缓存。我们可以存储（“缓存”）函数的结果，以便将来对同一个对象的调用可以重用这个结果。
171172

172-
我们可以使用 `Map` 来存储结果，就像这样：
173+
为了实现这一点，我们可以使用 `Map`（非最佳方案）：
173174

174175
```js run
175176
// 📁 cache.js
@@ -206,7 +207,7 @@ alert(cache.size); // 1（啊！该对象依然在 cache 中，并占据着内
206207

207208
对于多次调用同一个对象，它只需在第一次调用时计算出结果，之后的调用可以直接从 `cache` 中获取。这样做的缺点是，当我们不再需要这个对象的时候需要清理 `cache`。
208209

209-
如果我们用 `WeakMap` 替代 `Map`，这个问题便会消失：当对象被垃圾回收时，对应的缓存的结果也会被自动地从内存中清除。
210+
如果我们用 `WeakMap` 替代 `Map`，便不会存在这个问题。当对象被垃圾回收时，对应缓存的结果也会被自动从内存中清除。
210211

211212
```js run
212213
// 📁 cache.js
@@ -283,6 +284,8 @@ john = null;
283284

284285
`WeakSet` 是类似于 `Set` 的集合，它仅存储对象，并且一旦通过其他方式无法访问它们，便会将其删除。
285286

286-
它们都不支持引用所有键或其计数的方法和属性。仅允许单个操作。
287+
它们的主要优点是它们对对象是弱引用，所以被它们引用的对象很容易地被垃圾收集器移除。
288+
289+
这是以不支持 `clear`、`size`、`keys`、`values` 等作为代价换来的……
287290

288291
`WeakMap` 和 `WeakSet` 被用作“主要”对象存储之外的“辅助”数据结构。一旦将对象从主存储器中删除，如果该对象仅被用作 `WeakMap` 或 `WeakSet` 的键，那么它将被自动清除。

‎1-js/05-data-types/09-keys-values-entries/article.md‎

Lines changed: 6 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -77,7 +77,7 @@ for (let value of Object.values(user)) {
7777
如果我们想应用它们，那么我们可以使用 `Object.entries`，然后使用 `Object.fromEntries`：
7878

7979
1. 使用 `Object.entries(obj)` 从 `obj` 获取由键/值对组成的数组。
80-
2. 对该数组使用数组方法，例如 `map`。
80+
2. 对该数组使用数组方法，例如 `map`，对这些键/值对进行转换。
8181
3. 对结果数组使用 `Object.fromEntries(array)` 方法，将结果转回成对象。
8282

8383
例如，我们有一个带有价格的对象，并想将它们加倍：
@@ -91,12 +91,13 @@ let prices = {
9191

9292
*!*
9393
let doublePrices = Object.fromEntries(
94-
// 转换为数组，之后使用 map 方法，然后通过 fromEntries 再转回到对象
95-
Object.entries(prices).map(([key, value]) => [key, value * 2])
94+
// 将价格转换为数组，将每个键/值对映射为另一对
95+
// 然后通过 fromEntries 再将结果转换为对象
96+
Object.entries(prices).map(entry => [entry[0], entry[1] * 2])
9697
);
9798
*/!*
9899

99100
alert(doublePrices.meat); // 8
100-
```
101+
```
101102

102-
乍一看，可能看起来很困难，但是使用一次或两次后，就很容易理解了。我们可以通过这种方式建立强大的转换链。
103+
乍一看，可能感觉有点困难困难，但是使用一两次之后就很容易理解了。我们可以通过这种方式建立强大的转换链。

‎1-js/05-data-types/10-destructuring-assignment/6-max-salary/_js.view/solution.js‎

Lines changed: 3 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,14 @@
11
function topSalary(salaries) {
22

3-
let max = 0;
3+
let maxSalary = 0;
44
let maxName = null;
55

66
for(let [name, salary] of Object.entries(salaries)) {
7-
if (max < salary) {
8-
max = salary;
7+
if (maxSalary < salary) {
8+
maxSalary = salary;
99
maxName = name;
1010
}
1111
}
1212

1313
return maxName;
1414
}
15-
16-

0 commit comments

Comments
 (0)