diff --git a/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/solution.md b/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/solution.md index 27a7b418a..11b1c0205 100644 --- a/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/solution.md +++ b/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/solution.md @@ -17,12 +17,12 @@ let salaries = { alert( sumSalaries(salaries) ); // 650 ``` -Or, optionally, we could also get the sum using `Object.values` and `reduce`: +或，我們也可以使用 `Object.values` 和 `reduce` 取得總和： ```js -// reduce loops over array of salaries, -// adding them up -// and returns the result +// reduce 遍歷整個薪水的陣列 +// 把它們加總起來 +// 然後傳回結果 function sumSalaries(salaries) { return Object.values(salaries).reduce((a, b) => a + b, 0) // 650 } diff --git a/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/task.md b/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/task.md index 211357d03..0d742c65b 100644 --- a/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/task.md +++ b/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/task.md @@ -2,15 +2,15 @@ importance: 5 --- -# Sum the properties +# 把屬性加總 -There is a `salaries` object with arbitrary number of salaries. +這裡有個 `salaries` 物件，有任意的薪水數字。 -Write the function `sumSalaries(salaries)` that returns the sum of all salaries using `Object.values` and the `for..of` loop. +撰寫一個函式 `sumSalaries(salaries)`，該函式使用 `Object.values` 和 `for..of` 迴圈來傳回全部薪水的加總。 -If `salaries` is empty, then the result must be `0`. +如果 `salaries` 是空的，那麼結果必須是 `0`。 -For instance: +例如： ```js let salaries = { diff --git a/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md b/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md index d7aebb1fa..bdecc8586 100644 --- a/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md +++ b/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md @@ -4,7 +4,7 @@ importance: 5 # Count properties -Write a function `count(obj)` that returns the number of properties in the object: +寫一個函式 `count(obj)`，該函式會傳回物件有幾個屬性。 ```js let user = { @@ -15,7 +15,7 @@ let user = { alert( count(user) ); // 2 ``` -Try to make the code as short as possible. +嘗試把程式碼盡可能的變短吧。 -P.S. Ignore symbolic properties, count only "regular" ones. +備註：忽略符號的屬性，只計算 "一般的"。 diff --git a/1-js/05-data-types/09-keys-values-entries/article.md b/1-js/05-data-types/09-keys-values-entries/article.md index 4af192515..99baa61f0 100644 --- a/1-js/05-data-types/09-keys-values-entries/article.md +++ b/1-js/05-data-types/09-keys-values-entries/article.md @@ -1,42 +1,42 @@ # Object.keys, values, entries -Let's step away from the individual data structures and talk about the iterations over them. +我們先忽略個別資料結構，然後來討論關於在他們上面迭代這件事情。 -In the previous chapter we saw methods `map.keys()`, `map.values()`, `map.entries()`. +在前面的章節我們看過 `map.keys()`、`map.values()`、`map.entries()` 方法。 -These methods are generic, there is a common agreement to use them for data structures. If we ever create a data structure of our own, we should implement them too. +這些方法是通用的，這裡通常允許資料結構去使用他們。如果我們曾經建立自有的資料結構，那我們也應該實作他們。 -They are supported for: +他們可以支援： - `Map` - `Set` - `Array` -Plain objects also support similar methods, but the syntax is a bit different. +一般物件也支援類似的方法，但是語法有些不同。 ## Object.keys, values, entries -For plain objects, the following methods are available: +對於一般物件，有以下的方法可以使用： -- [Object.keys(obj)](mdn:js/Object/keys) -- returns an array of keys. -- [Object.values(obj)](mdn:js/Object/values) -- returns an array of values. -- [Object.entries(obj)](mdn:js/Object/entries) -- returns an array of `[key, value]` pairs. +- [Object.keys(obj)](mdn:js/Object/keys) -- 傳回鍵值陣列。 +- [Object.values(obj)](mdn:js/Object/values) -- 傳回值的陣列。 +- [Object.entries(obj)](mdn:js/Object/entries) -- 傳回 `[key, value]` 組成的陣列。 -Please note the distinctions (compared to map for example): +請注意區別（相較於 map 的範例）： | | Map | Object | |-------------|------------------|--------------| -| Call syntax | `map.keys()` | `Object.keys(obj)`, but not `obj.keys()` | -| Returns | iterable | "real" Array | +| 呼叫語法 | `map.keys()` | `Object.keys(obj)`，而不是 `obj.keys()` | +| 傳回 | 可迭代物件 | "實際的" 陣列 | -The first difference is that we have to call `Object.keys(obj)`, and not `obj.keys()`. +第一個區別是我們必須呼叫 `Object.keys(obj)`，而不是 `obj.keys()`。 -Why so? The main reason is flexibility. Remember, objects are a base of all complex structures in JavaScript. So we may have an object of our own like `data` that implements its own `data.values()` method. And we still can call `Object.values(data)` on it. +為何如此？主要原因是彈性。記住，在 JavaScript，所有複雜結構都是基於物件。所以我們可能自己有一個像是 `data` 的物件，該物件實作自有的 `data.values()` 方法。而且我們也可以對該物件呼叫 `Object.values(data)`。 -The second difference is that `Object.*` methods return "real" array objects, not just an iterable. That's mainly for historical reasons. +第二個區別是 `Object.*` 的方法回傳 "實際的" 陣列物件，而不只是一個可迭代物件。這主要是歷史的原因。 -For instance: +例如： ```js let user = { @@ -49,7 +49,7 @@ let user = { - `Object.values(user) = ["John", 30]` - `Object.entries(user) = [ ["name","John"], ["age",30] ]` -Here's an example of using `Object.values` to loop over property values: +這裡有一個使用 `Object.values` 去遍歷所有屬性值的範例： ```js run let user = { @@ -57,30 +57,30 @@ let user = { age: 30 }; -// loop over values +// 遍歷所有屬性值 for (let value of Object.values(user)) { - alert(value); // John, then 30 + alert(value); // John, 然後是 30 } ``` -```warn header="Object.keys/values/entries ignore symbolic properties" -Just like a `for..in` loop, these methods ignore properties that use `Symbol(...)` as keys. +```warn header="Object.keys/values/entries 會忽略符號的屬性" +就像 `for..in` 迴圈一樣，這些方法會忽略使用 `Symbol(...)` 作為鍵值的屬性。 -Usually that's convenient. But if we want symbolic keys too, then there's a separate method [Object.getOwnPropertySymbols](mdn:js/Object/getOwnPropertySymbols) that returns an array of only symbolic keys. Also, there exist a method [Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys) that returns *all* keys. +通常來說這很方便。但是，如果我們也需要符號鍵值的話，則有一個區分的方法 [Object.getOwnPropertySymbols](mdn:js/Object/getOwnPropertySymbols)，其傳回只有符號鍵值的陣列。另外，還存在一種方法 [Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys)，則傳回 **全部的** 鍵值。 ``` -## Transforming objects +## 轉換物件 -Objects lack many methods that exist for arrays, e.g. `map`, `filter` and others. +物件缺乏許多存在於陣列的方法，例如 `map`、`filter` 等。 -If we'd like to apply them, then we can use `Object.entries` followed `Object.fromEntries`: +如果我們想應用它們，那麼我們可以使用 `Object.entries` 之後使用 `Object.fromEntries`： -1. Use `Object.entries(obj)` to get an array of key/value pairs from `obj`. -2. Use array methods on that array, e.g. `map`. -3. Use `Object.fromEntries(array)` on the resulting array to turn it back into an object. +1. 使用 `Object.entries(obj)` 從 `obj` 取得鍵與值組合的陣列。 +2. 在該陣列上使用陣列方法，例如 `map`。 +3. 在最終結果的陣列使用 `Object.fromEntries(array)` 轉回成一個物件。 -For example, we have an object with prices, and would like to double them: +例如，我們有個一些價格組成的物件，然後想把它們變兩倍： ```js run let prices = { @@ -91,7 +91,7 @@ let prices = { *!* let doublePrices = Object.fromEntries( - // convert to array, map, and then fromEntries gives back the object + // 轉換成陣列，映射，然後以 fromEntries 回給物件 Object.entries(prices).map(([key, value]) => [key, value * 2]) ); */!* @@ -99,4 +99,4 @@ let doublePrices = Object.fromEntries( alert(doublePrices.meat); // 8 ``` -It may look difficult from the first sight, but becomes easy to understand after you use it once or twice. We can make powerful chains of transforms this way. +第一次看到時它看起來會很難懂，但是使用一兩次後，會變得很容易理解。我們可以用這個方式做出有力的轉換鏈式。 diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md index a35d19a7b..6b5aa701c 100644 --- a/9-regular-expressions/01-regexp-introduction/article.md +++ b/9-regular-expressions/01-regexp-introduction/article.md @@ -1,108 +1,101 @@ -# Patterns and flags +# 樣式（Patterns）與 旗標（flags） -Regular expressions are patterns that provide a powerful way to search and replace in text. +正規表達式（Regular expressions）是提供一種有力的方式在文字上去搜尋與取代的模式。 -In JavaScript, they are available via the [RegExp](mdn:js/RegExp) object, as well as being integrated in methods of strings. +在 JavaScript，它們可以藉由 [RegExp](mdn:js/RegExp) 物件使用，也整合進了字串的方法中。 -## Regular Expressions +## 正規表達式 -A regular expression (also "regexp", or just "reg") consists of a *pattern* and optional *flags*. +一個正規表達式（又稱 "regexp"，或只寫做 "reg"）由一個 **樣式** 與可選用的 **旗標** 組成。 -There are two syntaxes that can be used to create a regular expression object. +這裡有兩種語法可以用來建立一個正規表達式物件。 -The "long" syntax: +較長的語法： ```js regexp = new RegExp("pattern", "flags"); ``` -And the "short" one, using slashes `"/"`: +和較短的，使用斜線 `"/"`： ```js -regexp = /pattern/; // no flags -regexp = /pattern/gmi; // with flags g,m and i (to be covered soon) +regexp = /pattern/; // 沒有旗標 +regexp = /pattern/gmi; // 搭配旗標 g、m 和 i （等一下會講到） ``` -Slashes `pattern:/.../` tell JavaScript that we are creating a regular expression. They play the same role as quotes for strings. +斜線 `pattern:/.../` 會告訴 JavaScript 我們要建立一個正規表達式。它們扮演著跟字串引號相同的角色。 -In both cases `regexp` becomes an instance of the built-in `RegExp` class. +兩種請況下的 `regexp` 都會變成內建 `RegExp` 類別的實體。 -The main difference between these two syntaxes is that pattern using slashes `/.../` does not allow for expressions to be inserted (like string template literals with `${...}`). They are fully static. +兩種語法主要不同之處在於一種使用斜線 `/.../`，不允許插入表達式（像是字串樣板字面值 `${...}`）。他們是完全靜態的。 -Slashes are used when we know the regular expression at the code writing time -- and that's the most common situation. While `new RegExp`, is more often used when we need to create a regexp "on the fly" from a dynamically generated string. For instance: +斜線用在當我們撰寫程式碼時，所知道的正規表達式 -- 這是最常見的情況。而 `new RegExp`，經常用在我們需要用動態產生的字串建立一個 "即時" 的正規表達式。例如： ```js let tag = prompt("What tag do you want to find?", "h2"); -let regexp = new RegExp(`<${tag}>`); // same as /

/ if answered "h2" in the prompt above +let regexp = new RegExp(`<${tag}>`); // 如果在提示窗中回答 "h2"，則等同 /

/ ``` -## Flags +## 旗標 -Regular expressions may have flags that affect the search. +正規表達式可能會有影響搜尋結果的旗標。 -There are only 6 of them in JavaScript: +在 JavaScript 中只有6種： -`pattern:i` -: With this flag the search is case-insensitive: no difference between `A` and `a` (see the example below). +`pattern:i`：使用這個旗標會使搜尋不區分大小寫：`A` 與 `a` 不分（參見下面的範例） -`pattern:g` -: With this flag the search looks for all matches, without it -- only the first match is returned. +`pattern:g`：使用這個旗標會使搜尋查找所有匹配結果, 沒有這個的話 -- 只有第一個匹配結果會傳回。 -`pattern:m` -: Multiline mode (covered in the chapter ). +`pattern:m`：多行模式 (在此章節 介紹)。 -`pattern:s` -: Enables "dotall" mode, that allows a dot `pattern:.` to match newline character `\n` (covered in the chapter ). +`pattern:s`：啟用 "dotAll" 模式, 允許句點符號 `pattern:.` 去匹配換行字元 `\n`（在此章節 介紹）。 -`pattern:u` -: Enables full unicode support. The flag enables correct processing of surrogate pairs. More about that in the chapter . +`pattern:u`：啟用完整 unicode 支援。該旗標啟用了正確的代理對（surrogate pairs）處理。關於更多資訊會列在此章節 。 -`pattern:y` -: "Sticky" mode: searching at the exact position in the text (covered in the chapter ) +`pattern:y`："Sticky" 模式：搜尋在文本中的確切位置（在此章節 介紹） -```smart header="Colors" -From here on the color scheme is: +```smart header="顏色" +這裡的配色方式是： -- regexp -- `pattern:red` -- string (where we search) -- `subject:blue` -- result -- `match:green` +- 正規表達式 -- `pattern:紅色` +- 字串(我們搜尋的) -- `subject:藍色` +- 匹配結果 -- `match:綠色` ``` -## Searching: str.match +## 搜尋: str.match -As mentioned previously, regular expressions are integrated with string methods. +前面有提到，正規表達式有整合在字串的方法。 -The method `str.match(regexp)` finds all matches of `regexp` in the string `str`. +`str.match(regexp)` 方法用 `regexp` 正規表達式尋找在整個 `str` 字串中的所有匹配結果。 -It has 3 working modes: +它有 3 種運作模式： -1. If the regular expression has flag `pattern:g`, it returns an array of all matches: +1. 如果正規表達式有旗標 `pattern:g`，此傳回一個全部匹配結果的陣列： ```js run let str = "We will, we will rock you"; - alert( str.match(/we/gi) ); // We,we (an array of 2 substrings that match) + alert( str.match(/we/gi) ); // We,we (一個陣列內含 2 個匹配結果的部份字串) ``` - Please note that both `match:We` and `match:we` are found, because flag `pattern:i` makes the regular expression case-insensitive. + 請注意 `match:We` 和 `match:we` 皆被找到，是因為旗標 `pattern:i` 使正規表達式不分大小寫。 -2. If there's no such flag it returns only the first match in the form of an array, with the full match at index `0` and some additional details in properties: +2. 如果沒有旗標 `pattern:g` 傳回形式會是只有第一個匹配結果的陣列，該陣列中包含一些額外資訊在屬性中，完全匹配結果在索引 `0`： ```js run let str = "We will, we will rock you"; - let result = str.match(/we/i); // without flag g + let result = str.match(/we/i); // 不使用旗標 g - alert( result[0] ); // We (1st match) + alert( result[0] ); // We (1st 匹配結果) alert( result.length ); // 1 - // Details: - alert( result.index ); // 0 (position of the match) - alert( result.input ); // We will, we will rock you (source string) + // 額外資訊： + alert( result.index ); // 0 (匹配位置) + alert( result.input ); // We will, we will rock you (來源字串) ``` - The array may have other indexes, besides `0` if a part of the regular expression is enclosed in parentheses. We'll cover that in the chapter . + 如果正規表達式的一部分在括號中，則陣列除了 `0` 外還會有其他索引。我們將在此章節介紹 。 -3. And, finally, if there are no matches, `null` is returned (doesn't matter if there's flag `pattern:g` or not). - - This a very important nuance. If there are no matches, we don't receive an empty array, but instead receive `null`. Forgetting about that may lead to errors, e.g.: +3. 最後，如果沒有匹配結果，會傳回 `null`（與有無 `pattern:g` 旗標無關）。 + 這是很重要的細節。如果沒有匹配結果，我們不會收到一個空陣列，而是收到 `null`。忘記這件事情會導致錯誤，例如： ```js run let matches = "JavaScript".match(/HTML/); // = null @@ -112,50 +105,50 @@ It has 3 working modes: } ``` - If we'd like the result to always be an array, we can write it this way: + 如果我們想要結果永遠是一個陣列，我們可以這麼寫： ```js run let matches = "JavaScript".match(/HTML/)*!* || []*/!*; if (!matches.length) { - alert("No matches"); // now it works + alert("No matches"); // 現在會動了 } ``` -## Replacing: str.replace +## 取代: str.replace -The method `str.replace(regexp, replacement)` replaces matches found using `regexp` in string `str` with `replacement` (all matches if there's flag `pattern:g`, otherwise, only the first one). +`str.replace(regexp, replacement)` 方法用 `regexp` 找到了匹配結果，並在 `str` 字串使用 `replacement` 字串取代。（如果是 `pattern:g` 旗標的話，會是全部匹配結果，反之只會是第一個）。 -For instance: +例如： ```js run -// no flag g +// 沒有 g 旗標 alert( "We will, we will".replace(/we/i, "I") ); // I will, we will -// with flag g +// 有 g 旗標 alert( "We will, we will".replace(/we/ig, "I") ); // I will, I will ``` -The second argument is the `replacement` string. We can use special character combinations in it to insert fragments of the match: +第二個參數是 `replacement` 字串。我們可以在其中使用特殊字元组来插入匹配結果片段： -| Symbols | Action in the replacement string | +| 符號 | 取代字串的操作 | |--------|--------| -|`$&`|inserts the whole match| -|$`|inserts a part of the string before the match| -|`$'`|inserts a part of the string after the match| -|`$n`|if `n` is a 1-2 digit number, then it inserts the contents of n-th parentheses, more about it in the chapter | -|`$`|inserts the contents of the parentheses with the given `name`, more about it in the chapter | -|`$$`|inserts character `$` | +|`$&`|插入整個匹配結果| +|$`|插入匹配結果前面的字串| +|`$'`|插入匹配結果後面的字串| +|`$n`|如果 `n` 是一個 1 到 2 位元的數字，那會插入第 n 個括號中的內容，關於更多在此章節 | +|`$`|插入給定 `name` 括號中的內容, 關於更多在此章節 | +|`$$`|插入字元 `$` | -An example with `pattern:$&`: +`pattern:$&` 的範例： ```js run alert( "I love HTML".replace(/HTML/, "$& and JavaScript") ); // I love HTML and JavaScript ``` -## Testing: regexp.test +## 測試: regexp.test -The method `regexp.test(str)` looks for at least one match, if found, returns `true`, otherwise `false`. +`regexp.test(str)` 方法尋找至少一個匹配結果，如果有找到，傳回 `true`，反之則是 `false`。 ```js run let str = "I love JavaScript"; @@ -164,14 +157,14 @@ let regexp = /LOVE/i; alert( regexp.test(str) ); // true ``` -Later in this chapter we'll study more regular expressions, walk through more examples, and also meet other methods. +之後的章節我們將學習更多正規表達式，經過更多的範例，了解其他方法。 -Full information about the methods is given in the article . +關於方法的完整資訊在此文章 內提供。 -## Summary +## 總結 -- A regular expression consists of a pattern and optional flags: `pattern:g`, `pattern:i`, `pattern:m`, `pattern:u`, `pattern:s`, `pattern:y`. -- Without flags and special symbols (that we'll study later), the search by a regexp is the same as a substring search. -- The method `str.match(regexp)` looks for matches: all of them if there's `pattern:g` flag, otherwise, only the first one. -- The method `str.replace(regexp, replacement)` replaces matches found using `regexp` with `replacement`: all of them if there's `pattern:g` flag, otherwise only the first one. -- The method `regexp.test(str)` returns `true` if there's at least one match, otherwise, it returns `false`. +- 一個正規表達式由一個樣式和可選用的旗標組成，可選用旗標：`pattern:g`、`pattern:i`、`pattern:m`、`pattern:u`、`pattern:s`、`pattern:y`。 +- 除了旗標和特殊符號（我們等等會學到），用正規表達式來搜尋跟部份字串搜尋相同。 +- `str.match(regexp)` 方法尋找這些匹配：若有 `pattern:g` 旗標，找到全部匹配，否則，只找第一個匹配。 +- `str.replace(regexp, replacement)` 方法用 `regexp` 找到了匹配結果，並在 `str` 字串中使用 `replacement` 字串取代。：若有 `pattern:g` 旗標，取代全部匹配結果，反之只取代第一個匹配。 +- `regexp.test(str)` 方法尋找至少一個匹配結果，如果有找到，傳回 `true`，反之則是 `false`。