Map and Set

1-js/05-data-types/07-map-set/01-array-unique-map/task.md

@@ -2,17 +2,17 @@ importance: 5
 
 ---
 
-# Filter unique array members
+# 過濾掉重複的陣列成員
 
-Let `arr` be an array.
+令 `arr` 為一個陣列。
 
-Create a function `unique(arr)` that should return an array with unique items of `arr`.
+建立一個傳回沒有重複項目的函式 `unique(arr)`。
 
-For instance:
+例如：
 
 ```js
 function unique(arr) {
-  /* your code */
+  /* 你的程式碼 */
 }
 
 let values = ["Hare", "Krishna", "Hare", "Krishna",
@@ -22,6 +22,6 @@ let values = ["Hare", "Krishna", "Hare", "Krishna",
 alert( unique(values) ); // Hare, Krishna, :-O
 ```
 
-P.S. Here strings are used, but can be values of any type.
+附註：這裡雖然是用了字串，但也要可以是任何型別。
 
-P.P.S. Use `Set` to store unique values.
+追加附註：使用 `Set` 去儲放不重複的值。

1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md

@@ -1,6 +1,6 @@
-To find all anagrams, let's split every word to letters and sort them. When letter-sorted, all anagrams are same.
+找到所有易位構詞（anagrams）讓我們分解每個單字為字母並為其排序。當排序好字母時，所有易位構詞是相同的。
 
-For instance:
+例如：
 
 ```
 nap, pan -> anp
@@ -9,14 +9,14 @@ cheaters, hectares, teachers -> aceehrst
 ...
 ```
 
-We'll use the letter-sorted variants as map keys to store only one value per each key:
+我們將使用字母排序後的變動值作為對應鍵值，每個鍵值僅存儲一個值：
 
 ```js run
 function aclean(arr) {
   let map = new Map();
 
   for (let word of arr) {
-    // split the word by letters, sort them and join back
+    // 分解單字成字母，排序他們之後在合併起來
 *!*
     let sorted = word.toLowerCase().split('').sort().join(''); // (*)
 */!*
@@ -31,9 +31,9 @@ let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 alert( aclean(arr) );
 ```
 
-Letter-sorting is done by the chain of calls in the line `(*)`.
+字母排序是藉由呼叫串鏈，那行後面註解有個 `(*)`。
 
-For convenience let's split it into multiple lines:
+為了方便了解，我們分解成多行：
 
 ```js
 let sorted = word // PAN
@@ -43,21 +43,21 @@ let sorted = word // PAN
   .join(''); // anp
 ```
 
-Two different words `'PAN'` and `'nap'` receive the same letter-sorted form `'anp'`.
+收到 `'PAN'` 和 `'nap'` 兩個不同單字為相同字母排列形式 `'anp'`。
 
-The next line put the word into the map:
+在下一行把這些單字放入 map：
 
 ```js
 map.set(sorted, word);
 ```
 
-If we ever meet a word the same letter-sorted form again, then it would overwrite the previous value with the same key in the map. So we'll always have at maximum one word per letter-form.
+如果我們再次遇到相同字母排列形式的單字，那麼該單字將會在 map 的鍵值上覆蓋原先的值。因此，每個字母形式最多只能有一個單字。
 
-At the end `Array.from(map.values())` takes an iterable over map values (we don't need keys in the result) and returns an array of them.
+最後 `Array.from(map.values())`  對 map 中的值進行迭代（我們不需要鍵值）並傳回它們的陣列。
 
-Here we could also use a plain object instead of the `Map`, because keys are strings.
+在這裡我們也可以使用一個普通物件而不是 `Map`，因為鍵值是字串。
 
-That's how the solution can look:
+這就是解決方案供參：
 
 ```js run demo
 function aclean(arr) {

1-js/05-data-types/07-map-set/02-filter-anagrams/task.md

@@ -2,27 +2,27 @@ importance: 4
 
 ---
 
-# Filter anagrams
+# 過濾易位構詞
 
-[Anagrams](https://en.wikipedia.org/wiki/Anagram) are words that have the same number of same letters, but in different order.
+[易位構詞](https://zh.wikipedia.org/wiki/易位構詞遊戲) 是具有相同數量字母但順序不同的單字。
 
-For instance:
+例如：
 
 ```
 nap - pan
 ear - are - era
 cheaters - hectares - teachers
 ```
 
-Write a function `aclean(arr)` that returns an array cleaned from anagrams.
+撰寫一個函式 `aclean(arr)`，傳回不重複的易位構詞陣列。
 
-For instance:
+例如：
 
 ```js
 let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 
 alert( aclean(arr) ); // "nap,teachers,ear" or "PAN,cheaters,era"
 ```
 
-From every anagram group should remain only one word, no matter which one.
+在每個易位構詞群組中，無論哪個單字，都應只保留一個單字。
 

1-js/05-data-types/07-map-set/03-iterable-keys/solution.md

@@ -1,7 +1,7 @@
 
-That's because `map.keys()` returns an iterable, but not an array.
+那是因為 `map.keys()` 傳回的是可迭代的物件，但不是一個陣列。
 
-We can convert it into an array using `Array.from`:
+我們可以轉換它變成陣列使用 `Array.from`：
 
 
 ```js run

1-js/05-data-types/07-map-set/03-iterable-keys/task.md

@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Iterable keys
+# 可迭代鍵值
 
-We'd like to get an array of `map.keys()` in a variable and then do apply array-specific methods to it, e.g. `.push`.
+我們想在變數中獲得一個執行 `map.keys()` 後的陣列，然後使用陣列的方法，像是 `.push`。
 
-But that doesn't work:
+但那是不會動的：
 
 ```js run
 let map = new Map();
@@ -21,4 +21,4 @@ keys.push("more");
 */!*
 ```
 
-Why? How can we fix the code to make `keys.push` work?
+為什麼？我們該如何修改程式碼使 `keys.push` 能動？

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

@@ -1,95 +1,95 @@
 
-# Map and Set
+# Map and 集合
 
-Now we've learned about the following complex data structures:
+現在，我們已經了解了以下複雜的資料結構：
 
-- Objects for storing keyed collections.
-- Arrays for storing ordered collections.
+- 物件，儲放有鍵值的群集
+- 陣列，儲放有順序的群集
 
-But that's not enough for real life. That's why `Map` and `Set` also exist.
+但事實上這還不夠。這就是為什麼還有 `Map` 和 `Set`。
 
 ## Map
 
-[Map](mdn:js/Map) is a collection of keyed data items, just like an `Object`. But the main difference is that `Map` allows keys of any type.
+[Map](mdn:js/Map) 是有鍵值的資料群集，就跟一個 `Object` 一樣。主要的區別是 `Map` 允許任何類型的鍵值。
 
-Methods and properties are:
+方法和屬性有：
 
-- `new Map()` -- creates the map.
-- `map.set(key, value)` -- stores the value by the key.
-- `map.get(key)` -- returns the value by the key, `undefined` if `key` doesn't exist in map.
-- `map.has(key)` -- returns `true` if the `key` exists, `false` otherwise.
-- `map.delete(key)` -- removes the value by the key.
-- `map.clear()` -- removes everything from the map.
-- `map.size` -- returns the current element count.
+- `new Map()` -- 建立一個 map。
+- `map.set(key, value)` -- 儲放值藉由鍵值。
+- `map.get(key)` -- 傳回值藉由鍵值，如果 `key` 不存在於 map 則是 `undefined`。
+- `map.has(key)` -- 如果鍵值存在傳回 `true`，反之則是 `false`。
+- `map.delete(key)` -- 移除值藉由鍵值。
+- `map.clear()` -- 移除所有值。
+- `map.size` -- 傳回現在元素數量。
 
-For instance:
+例如：
 
 ```js run
 let map = new Map();
 
-map.set('1', 'str1');   // a string key
-map.set(1, 'num1');     // a numeric key
-map.set(true, 'bool1'); // a boolean key
+map.set('1', 'str1');   // 一個字串鍵值
+map.set(1, 'num1');     // 一個數值鍵值
+map.set(true, 'bool1'); // 一個布林值鍵值
 
-// remember the regular Object? it would convert keys to string
-// Map keeps the type, so these two are different:
+// 記得一般的物件嗎？它會將鍵值轉換成字串
+// map 會保持原本的型別，所以這兩者是不同的：
 alert( map.get(1)   ); // 'num1'
 alert( map.get('1') ); // 'str1'
 
 alert( map.size ); // 3
 ```
 
-As we can see, unlike objects, keys are not converted to strings. Any type of key is possible.
+有此可見，不同於物件，鍵值不會轉換成字串。任何類型的鍵值都是可行的。
 
-```smart header="`map[key]` isn't the right way to use a `Map`"
-Although `map[key]` also works, e.g. we can set `map[key] = 2`, this is treating `map` as a plain JavaScript object, so it implies all corresponding limitations (no object keys and so on).
+```smart header="`map[key]` 不是 `Map` 的正確使用方法"
+雖然 `map[key]` 也會動，例如我們可以設置 `map[key] = 2`，這會將 `map` 當作一般的 JavaScript 物件，所以，會有相應的限制（物件的鍵值等等）。
 
-So we should use `map` methods: `set`, `get` and so on.
+所以我們應該使用 `map` 方法：`set`、`get` 等等。
 ```
 
-**Map can also use objects as keys.**
+**map 可以將物件作為鍵值。**
 
-For instance:
+例如：
 
 ```js run
 let john = { name: "John" };
 
-// for every user, let's store their visits count
+// 供全部用戶，讓我們來存放他們的拜訪計數
 let visitsCountMap = new Map();
 
-// john is the key for the map
+// john 是 map 的鍵值
 visitsCountMap.set(john, 123);
 
 alert( visitsCountMap.get(john) ); // 123
 ```
 
-Using objects as keys is one of most notable and important `Map` features. For string keys, `Object` can be fine, but not for object keys.
+將物件作為鍵值是 `Map` 最著名且重要的功能之一。以字串鍵值來說，`Object` 就可以，但如果是物件的鍵值就不是了。
 
-Let's try:
+讓我們來試試：
 
 ```js run
 let john = { name: "John" };
 
-let visitsCountObj = {}; // try to use an object
+let visitsCountObj = {}; // 嘗試使用物件
 
-visitsCountObj[john] = 123; // try to use john object as the key
+visitsCountObj[john] = 123; // 嘗試使用 john 物件作為鍵值
 
 *!*
-// That's what got written!
+// 這寫入了這個！
 alert( visitsCountObj["[object Object]"] ); // 123
 */!*
 ```
 
-As `visitsCountObj` is an object, it converts all keys, such as `john` to strings, so we've got the string key `"[object Object]"`. Definitely not what we want.
+由於 `visitsCountObj` 是一個物件，他會將所有的鍵值轉換成字串（像是 `john`）因此我們得到了字串鍵值 `"[object Object]"`。 絕對不是我們所要的。
 
-```smart header="How `Map` compares keys"
-To test keys for equivalence, `Map` uses the algorithm [SameValueZero](https://tc39.github.io/ecma262/#sec-samevaluezero). It is roughly the same as strict equality `===`, but the difference is that `NaN` is considered equal to `NaN`. So `NaN` can be used as the key as well.
+```smart header="`Map` 如何比較鍵值"
+為了測試鍵值相等，`Map` 使用演算法 [SameValueZero](https://tc39.github.io/ecma262/#sec-samevaluezero)。它大致與嚴格等於 `===` 相同，但不同的地方是 `NaN` 視同 `NaN`。所以 `NaN` 也可以作為鍵值。
 
-This algorithm can't be changed or customized.
+這個演算法不可以被改變或自訂。
 ```
 
-````smart header="Chaining"
-Every `map.set` call returns the map itself, so we can "chain" the calls:
+````smart header="串鏈"
+每個 `map.set` 呼叫都會傳回 map 自己，所以我們可以 "串鏈" 這些呼叫：
 
 ```js
 map.set('1', 'str1')
@@ -99,15 +99,15 @@ map.set('1', 'str1')
 ````
 
 
-## Iteration over Map
+## 在 map 上迭代
 
-For looping over a `map`, there are 3 methods:
+要遍歷整個 map，有 3 個方法：
 
-- `map.keys()` -- returns an iterable for keys,
-- `map.values()` -- returns an iterable for values,
-- `map.entries()` -- returns an iterable for entries `[key, value]`, it's used by default in `for..of`.
+- `map.keys()` -- 傳回一個可迭代鍵值的物件，
+- `map.values()` -- 傳回一個可迭代值的物件
+- `map.entries()` -- 傳回一個可迭代條目 `[key, value]`，它可以用在 `for..of`。
 
-For instance:
+例如：
 
 ```js run
 let recipeMap = new Map([
@@ -116,41 +116,41 @@ let recipeMap = new Map([
   ['onion',    50]
 ]);
 
-// iterate over keys (vegetables)
+// 迭代全部的鍵值（蔬菜）
 for (let vegetable of recipeMap.keys()) {
   alert(vegetable); // cucumber, tomatoes, onion
 }
 
-// iterate over values (amounts)
+// 迭代全部的值（價格）
 for (let amount of recipeMap.values()) {
   alert(amount); // 500, 350, 50
 }
 
-// iterate over [key, value] entries
-for (let entry of recipeMap) { // the same as of recipeMap.entries()
-  alert(entry); // cucumber,500 (and so on)
+// 迭代全部的 [key, value] 條目
+for (let entry of recipeMap) { // 這等同於 recipeMap.entries()
+  alert(entry); // cucumber,500（等等）
 }
 ```
 
-```smart header="The insertion order is used"
-The iteration goes in the same order as the values were inserted. `Map` preserves this order, unlike a regular `Object`.
+```smart header="依照插入順序"
+迭代的順序與插入值的順序相同。 與一般的 `Object` 不同，`Map` 保留了此順序。
 ```
 
-Besides that, `Map` has a built-in `forEach` method, similar to `Array`:
+除此之外，`Map` 有內建的 `forEach` 方法，類似於 `Array`：
 
 ```js
-// runs the function for each (key, value) pair
+// 執行函數時每次傳入一對鍵與值
 recipeMap.forEach( (value, key, map) => {
-  alert(`${key}: ${value}`); // cucumber: 500 etc
+  alert(`${key}: ${value}`); // cucumber: 500 等等
 });
 ```
 
-## Object.entries: Map from Object
+## Object.entries: 從 Object 建立 Map
 
-When a `Map` is created, we can pass an array (or another iterable) with key/value pairs for initialization, like this:
+當建立一個 `Map` 時，我們可以傳入一個鍵/值組合的陣列（或可迭代的物件）進行初始化，如下：
 
 ```js run
-// array of [key, value] pairs
+// [key, value] 組合的陣列
 let map = new Map([
   ['1',  'str1'],
   [1,    'num1'],
@@ -160,9 +160,9 @@ let map = new Map([
 alert( map.get('1') ); // str1
 ```
 
-If we have a plain object, and we'd like to create a `Map` from it, then we can use built-in method [Object.entries(obj)](mdn:js/Object/entries) that returns an array of key/value pairs for an object exactly in that format.
+如果我們有一個普通的物件，並且想從該物件建立一個 `Map`，則可以使用內建方法 [Object.entries(obj)](mdn:js/Object/entries) ，傳回一個與其相同格式的鍵/值組合的陣列。
 
-So we can create a map from an object like this:
+所以，我們可以從物件建立一個 map，如下：
 
 ```js run
 let obj = {
@@ -177,14 +177,14 @@ let map = new Map(Object.entries(obj));
 alert( map.get('name') ); // John
 ```
 
-Here, `Object.entries` returns the array of key/value pairs: `[ ["name","John"], ["age", 30] ]`. That's what `Map` needs.
+在這裡，`Object.entries` 傳回一個鍵/值組合的陣列：`[ ["name","John"], ["age", 30] ]`。這是 `Map` 所需要的。
 
 
-## Object.fromEntries: Object from Map
+## Object.fromEntries: 從 Map 建立 Object
 
-We've just seen how to create `Map` from a plain object with `Object.entries(obj)`.
+我們已經看到如何使用 `Object.entries(obj)` 從一般物件建立 `Map`。
 
-There's `Object.fromEntries` method that does the reverse: given an array of `[key, value]` pairs, it creates an object from them:
+有一個 `Object.fromEntries` 方法可以反過來：給定一個 `[key，value]` 組合的陣列，根據該陣列建立物件：
 
 ```js run
 let prices = Object.fromEntries([
@@ -193,16 +193,16 @@ let prices = Object.fromEntries([
   ['meat', 4]
 ]);
 
-// now prices = { banana: 1, orange: 2, meat: 4 }
+// 現在 prices = { banana: 1, orange: 2, meat: 4 }
 
 alert(prices.orange); // 2
 ```
 
-We can use `Object.fromEntries` to get an plain object from `Map`.
+我們可以使用 `Object.fromEntries` 從 `Map` 得到一個一般物件。
 
-E.g. we store the data in a `Map`, but we need to pass it to a 3rd-party code that expects a plain object.
+例如我們將數據儲放在 `Map` 中，但是我們需要將其傳給期望使用一般物件的第三方程式碼。
 
-Here we go:
+我們開始吧：
 
 ```js run
 let map = new Map();
@@ -211,42 +211,42 @@ map.set('orange', 2);
 map.set('meat', 4);
 
 *!*
-let obj = Object.fromEntries(map.entries()); // make a plain object (*)
+let obj = Object.fromEntries(map.entries()); // 做出一個一般物件 (*)
 */!*
 
-// done!
+// 好了！
 // obj = { banana: 1, orange: 2, meat: 4 }
 
 alert(obj.orange); // 2
 ```
 
-A call to `map.entries()` returns an array of key/value pairs, exactly in the right format for `Object.fromEntries`.
+呼叫 `map.entries()` 傳回一個鍵/值組合的陣列，與 `Object.fromEntries` 所需的格式相同。
 
-We could also make line `(*)` shorter:
+我們可以將註解有 `(*)` 那行縮短：
 ```js
-let obj = Object.fromEntries(map); // omit .entries()
+let obj = Object.fromEntries(map); // 忽略 .entries()
 ```
 
-That's the same, because `Object.fromEntries` expects an iterable object as the argument. Not necessarily an array. And the standard iteration for `map` returns same key/value pairs as `map.entries()`. So we get a plain object with same key/values as the `map`.
+這是一樣的的，因為 `Object.fromEntries` 期望一個可迭代物件作為參數。不一定要是陣列。而 `map` 預設迭代會使用 `map.entries()` 傳回鍵/值組合，所以我們會得到一個跟 `map` 相同鍵/值組合的物件。
 
-## Set
+## 集合
 
-A `Set` is a special type collection - "set of values" (without keys), where each value may occur only once.
+`Set` 是一種特殊的類型群集 - "值的集合" (沒有鍵值)，其中每個值只會有一個。
 
-Its main methods are:
+他主要的方法有：
 
-- `new Set(iterable)` -- creates the set, and if an `iterable` object is provided (usually an array), copies values from it into the set.
-- `set.add(value)` -- adds a value, returns the set itself.
-- `set.delete(value)` -- removes the value, returns `true` if `value` existed at the moment of the call, otherwise `false`.
-- `set.has(value)` -- returns `true` if the value exists in the set, otherwise `false`.
-- `set.clear()` -- removes everything from the set.
-- `set.size` -- is the elements count.
+- `new Set(iterable)` -- 建立集合，然後如果有給 `iterable` 可迭代物件（通常是陣列），複製其值到該集合中。
+- `set.add(value)` -- 新增一個值，傳回集合自己。
+- `set.delete(value)` -- 移除該值，如果當下存在該值傳回 `true`，反之則是 `false`。
+- `set.has(value)` -- 如果該值存在於集合中傳回 `true`，反之則是 `false`。
+- `set.clear()` -- 移除所有值。
+- `set.size` -- 傳回現在元素數量。
 
-The main feature is that repeated calls of `set.add(value)` with the same value don't do anything. That's the reason why each value appears in a `Set` only once.
+主要功能是重複呼叫具有相同值的 `set.add（value)` 時不會發生任何事。這就是每個值只在 `Set` 中出現一次的原因。
 
-For example, we have visitors coming, and we'd like to remember everyone. But repeated visits should not lead to duplicates. A visitor must be "counted" only once.
+例如，我們有訪客來，然後我們想記住每個人。但是不該有重複的訪問。訪客只能被 "計入" 一次。
 
-`Set` is just the right thing for that:
+`Set` 正好是個正確的選擇：
 
 ```js run
 let set = new Set();
@@ -255,76 +255,76 @@ let john = { name: "John" };
 let pete = { name: "Pete" };
 let mary = { name: "Mary" };
 
-// visits, some users come multiple times
+// 有些用戶來拜訪多次
 set.add(john);
 set.add(pete);
 set.add(mary);
 set.add(john);
 set.add(mary);
 
-// set keeps only unique values
+// 集合只保留唯一值
 alert( set.size ); // 3
 
 for (let user of set) {
-  alert(user.name); // John (then Pete and Mary)
+  alert(user.name); // John (然後 Pete 和 Mary)
 }
 ```
 
-The alternative to `Set` could be an array of users, and the code to check for duplicates on every insertion using [arr.find](mdn:js/Array/find). But the performance would be much worse, because this method walks through the whole array checking every element. `Set` is much better optimized internally for uniqueness checks.
+`Set` 的替代方法可以是一個用戶陣列，使用 [arr.find](mdn:js/Array/find) 在每次插入時檢查重複。但是效率會很差，因為此方法遍歷整個陣列，檢查每個元素。`Set` 在內部有更好的優化進行唯一性檢查。
 
-## Iteration over Set
+## 在集合上迭代
 
-We can loop over a set either with `for..of` or using `forEach`:
+我們可以使用 `for..of` 或 `forEach` 遍歷一個集合：
 
 ```js run
 let set = new Set(["oranges", "apples", "bananas"]);
 
 for (let value of set) alert(value);
 
-// the same with forEach:
+// 同樣在 forEach:
 set.forEach((value, valueAgain, set) => {
   alert(value);
 });
 ```
 
-Note the funny thing. The callback function passed in `forEach` has 3 arguments: a `value`, then *the same value* `valueAgain`, and then the target object. Indeed, the same value appears in the arguments twice.
+有趣的是，在 `forEach` 中傳遞的回呼函式有 3 個參數：一個 `value`，然後是 **相同值** `valueAgain`，然後是目標物件。 實際上，相同的值在參數中出現兩次。
 
-That's for compatibility with `Map` where the callback passed `forEach` has three arguments. Looks a bit strange, for sure. But may help to replace `Map` with `Set` in certain cases with ease, and vice versa.
+這是為了與 `Map` 兼容，在其中回呼傳遞的 `forEach` 具有三個參數。看起來確實有些奇怪。但是在某些情況下可以輕鬆地用 `Set` 替換 `Map`，反之亦然。
 
-The same methods `Map` has for iterators are also supported:
+也支援與 `Map` 相同的迭代器方法：
 
-- `set.keys()` -- returns an iterable object for values,
-- `set.values()` -- same as `set.keys()`, for compatibility with `Map`,
-- `set.entries()` -- returns an iterable object for entries `[value, value]`, exists for compatibility with `Map`.
+- `set.keys()` -- 傳回一個可迭代值的物件，
+- `set.values()` -- 同 `set.keys()`，為了與 `Map` 兼容，
+- `set.entries()` -- 傳回一個可迭代條目 `[value, value]`，存在是為了與 `Map` 兼容。
 
-## Summary
+## 總結
 
-`Map` -- is a collection of keyed values.
+`Map` -- 是有鍵值的資料群集。
 
-Methods and properties:
+方法和屬性有：
 
-- `new Map([iterable])` -- creates the map, with optional `iterable` (e.g. array) of `[key,value]` pairs for initialization.
-- `map.set(key, value)` -- stores the value by the key.
-- `map.get(key)` -- returns the value by the key, `undefined` if `key` doesn't exist in map.
-- `map.has(key)` -- returns `true` if the `key` exists, `false` otherwise.
-- `map.delete(key)` -- removes the value by the key.
-- `map.clear()` -- removes everything from the map.
-- `map.size` -- returns the current element count.
+- `new Map([iterable])` -- 建立一個 map，可以有 `[key,value]` 組合的 `iterable` 可迭代物件（像是陣列）供初始化。
+- `map.set(key, value)` -- 儲放值藉由鍵值。
+- `map.get(key)` -- 傳回值藉由鍵值，如果 `key` 不存在於 map 則是 `undefined`。
+- `map.has(key)` -- 如果鍵值存在傳回 `true`，反之則是 `false`。
+- `map.delete(key)` -- 移除值藉由鍵值。
+- `map.clear()` -- 移除所有值。
+- `map.size` -- 傳回現在元素數量。
 
-The differences from a regular `Object`:
+不同於一般的 `Object`：
 
-- Any keys, objects can be keys.
-- Additional convenient methods, the `size` property.
+- 任何鍵值，物件也能當鍵值。
+- 方便的額外方法，屬性 `size`。
 
-`Set` -- is a collection of unique values.
+`Set` -- 是唯一值的群集。
 
-Methods and properties:
+方法和屬性有：
 
-- `new Set([iterable])` -- creates the set, with optional `iterable` (e.g. array) of values for initialization.
-- `set.add(value)` -- adds a value (does nothing if `value` exists), returns the set itself.
-- `set.delete(value)` -- removes the value, returns `true` if `value` existed at the moment of the call, otherwise `false`.
-- `set.has(value)` -- returns `true` if the value exists in the set, otherwise `false`.
-- `set.clear()` -- removes everything from the set.
-- `set.size` -- is the elements count.
+- `new Set(iterable)` -- 建立集合，然後如果有給 `iterable` 可迭代物件（通常是陣列），複製其值到該集合中。
+- `set.add(value)` -- 新增一個值，傳回集合自己。
+- `set.delete(value)` -- 移除該值，如果當下存在該值傳回 `true`，反之則是 `false`。
+- `set.has(value)` -- 如果該值存在於集合中傳回 `true`，反之則是 `false`。
+- `set.clear()` -- 移除所有值。
+- `set.size` -- 傳回現在元素數量。
 
-Iteration over `Map` and `Set` is always in the insertion order, so we can't say that these collections are unordered, but we can't reorder elements or directly get an element by its number.
+`Map` 和 `Set` 上的迭代始終按插入順序進行，因此我們不能說這些群集是無序的，但是我們不能對元素進行重新排序或直接按其編號獲取元素。