feat: update translation

Author: leviding

9-regular-expressions/13-regexp-alternation/01-find-programming-language/solution.md

@@ -1,33 +1,33 @@
 
-第一个解法是列出所有语言，中间加上 `|` 符号。
+首先想到的解法是列出所有编程语言，在它们之间加上 `|` 符号。
 
-但是运行不如所愿：
+但运行结果不符合预期：
 
 ```js run
-let reg = /Java|JavaScript|PHP|C|C\+\+/g;
+let regexp = /Java|JavaScript|PHP|C|C\+\+/g;
 
 let str = "Java, JavaScript, PHP, C, C++";
 
-alert( str.match(reg) ); // Java,Java,PHP,C,C
+alert( str.match(regexp) ); // Java,Java,PHP,C,C
 ```
 
-正则表达式引擎查找选择模式的时是挨个查找的。意思是：它先匹配是否存在 `match:Java`，否则 —— 接着匹配 `match:JavaScript` 及其后的字符串。
+正则表达式引擎注意查找选择。也就是说：它先检查是否存在 `match:Java`，不存在 —— 接着匹配 `match:JavaScript` 及其后的字符串。
 
 结果，`match:JavaScript` 永远匹配不到，因为 `match:Java` 先被匹配了。
 
 `match:C` 和 `match:C++` 同理。
 
-这个问题有两个解决办法：
+这个问题有两个解决方式：
 
-1. 变更匹配顺序，长的字符串优先匹配：`pattern:JavaScript|Java|C\+\+|C|PHP`。
+1. 更改顺序以先检查较长的匹配项：`pattern:JavaScript|Java|C\+\+|C|PHP`。
 2. 合并相同前缀：`pattern:Java(Script)?|C(\+\+)?|PHP`。
 
-运行代码如下：
+测试一下：
 
 ```js run
-let reg = /Java(Script)?|C(\+\+)?|PHP/g;
+let regexp = /Java(Script)?|C(\+\+)?|PHP/g;
 
 let str = "Java, JavaScript, PHP, C, C++";
 
-alert( str.match(reg) ); // Java,JavaScript,PHP,C,C++
+alert( str.match(regexp) ); // Java,JavaScript,PHP,C,C++
 ```

9-regular-expressions/13-regexp-alternation/01-find-programming-language/task.md

@@ -1,11 +1,11 @@
 # 查找编程语言
 
-有许多编程语言，例如 Java, JavaScript, PHP, C, C++。
+有很多编程语言，例如 Java、JavaScript、PHP、C 或 C++。
 
-构建一个正则式，用来匹配字符串 `subject:Java JavaScript PHP C++ C` 中包含的编程语言：
+构建一个正则表达式，用来匹配字符串 `subject:Java JavaScript PHP C++ C` 中包含的编程语言：
 
 ```js
-let reg = /your regexp/g;
+let regexp = /你的正则表达式/g;
 
-alert("Java JavaScript PHP C++ C".match(reg)); // Java JavaScript PHP C++ C
+alert("Java JavaScript PHP C++ C".match(regexp)); // Java JavaScript PHP C++ C
 ```

9-regular-expressions/13-regexp-alternation/02-find-matching-bbtags/solution.md

@@ -1,14 +1,14 @@
 
 起始标签是 `pattern:\[(b|url|quote)\]`。
 
-匹配字符串直到遇到结束标签 —— 模式 `pattern:[\s\S]*?` 匹配任意字符，包括换行和用于结束标记的反向引用。
+匹配字符串直到遇到结束标签 —— 让我们使用模式 `pattern:.*?` 和修饰符 `pattern:s` 来匹配包括换行符在内的任何字符，然后向结束标签添加反向引用。
 
-完整模式为：`pattern:\[(b|url|quote)\][\s\S]*?\[/\1\]`。
+完整模式为：`pattern:\[(b|url|quote)\].*?\[/\1]`。
 
-运行代码如下：
+代码运行如下：
 
 ```js run
-let reg = /\[(b|url|quote)\][\s\S]*?\[\/\1\]/g;
+let regexp = /\[(b|url|quote)].*?\[\/\1]/gs;
 
 let str = `
   [b]hello![/b]
@@ -17,7 +17,7 @@ let str = `
   [/quote]
 `;
 
-alert( str.match(reg) ); // [b]hello![/b],[quote][url]http://google.com[/url][/quote]
+alert( str.match(regexp) ); // [b]hello![/b],[quote][url]http://google.com[/url][/quote]
 ```
 
-请注意我们要转义结束标签 `pattern:[/\1]` 中的斜杠，通常斜杠会关闭模式。
+请注意，除了转义 `pattern:[` 之外，我们还必须为结束标签 `pattern:[\/\1]` 转义一个斜线，因为通常斜线会关闭模式。

9-regular-expressions/13-regexp-alternation/02-find-matching-bbtags/task.md

@@ -1,6 +1,6 @@
 # 查找 bbtag 对
 
-“bb-tag” 形如 `[tag]...[/tag]`，`tag` 匹配 `b`、`url` 或 `quote` 其中之一。
+“bb-tag” 形如 `[tag]...[/tag]`，`tag` 匹配 `b`、`url` 或 `quote` 中之一。
 
 例如：
 ```
@@ -11,38 +11,38 @@
 BB-tags 可以嵌套。但标签不能自嵌套，比如：
 
 ```
-可行：
+可以：
 [url] [b]http://google.com[/b] [/url]
 [quote] [b]text[/b] [/quote]
 
-不可行：
+不可以：
 [b][b]text[/b][/b]
 ```
 
-标签可以包含换行，通常为以下形式：
+标签可以包含换行，通常：
 
 ```
 [quote]
   [b]text[/b]
 [/quote]
 ```
 
-构造一个正则式用于查找所有 BB-tags 和其内容。
+构造一个正则表达式用于查找所有 BB-tags 及其内容。
 
-举例：
+例如：
 
 ```js
-let reg = /your regexp/g;
+let regexp = /your regexp/flags;
 
 let str = "..[url]http://google.com[/url]..";
-alert( str.match(reg) ); // [url]http://google.com[/url]
+alert( str.match(regexp) ); // [url]http://google.com[/url]
 ```
 
-如果标签嵌套，那么我们需要记录匹配的外层标签（如果希望继续查找匹配的标签内容的话）：
+如果标签嵌套，那么我们需要记录匹配的外层标签（如果需要，我们可以继续在其内容中搜索）：
 
 ```js
-let reg = /your regexp/g;
+let regexp = /你的正则表达式/flags;
 
 let str = "..[url][b]http://google.com[/b][/url]..";
-alert( str.match(reg) ); // [url][b]http://google.com[/b][/url]
+alert( str.match(regexp) ); // [url][b]http://google.com[/b][/url]
 ```

9-regular-expressions/13-regexp-alternation/03-match-quoted-string/solution.md

@@ -1,17 +1,17 @@
-答案是 `pattern:/"(\\.|[^"\\])*"/g`。
+解决方案：`pattern:/"(\\.|[^"\\])*"/g`。
 
-步骤如下：
+一步一步来分析一下：
 
 - 首先匹配左双引号 `pattern:"`
-- 接着如果有反斜杠 `pattern:\\`，则匹配其后跟随的任意字符。（技术上，我们必须在模式中用双反斜杠，因为它是一个特殊的字符，但实际上是一个反斜杠字符）
-- 如果没有，则匹配除双引号（字符串的结束）和反斜杠（排除仅存在反斜杠的情况，反斜杠仅在和其后字符一起使用时有效）外的任意字符：`pattern:[^"\\]`
-- ...继续匹配直到遇到反双引号
+- 接着如果有反斜线 `pattern:\\`，则匹配其后跟随的任意字符（.）。（技术上，我们必须在模式中用双反斜线，因为它是一个特殊的字符，但实际上是一个反斜线字符）。
+- 如果没有，则匹配除双引号（表示字符串的末尾）和反斜线（排除仅存在反斜杠的情况，反斜杠仅在和其后字符一起使用时有效）外的任何字符：`pattern:[^"\\]`。
+- ……继续匹配直到遇到右双引号
 
-运行代码如下：
+代码运行如下：
 
 ```js run
-let reg = /"(\\.|[^"\\])*"/g;
+let regexp = /"(\\.|[^"\\])*"/g;
 let str = ' .. "test me" .. "Say \\"Hello\\"!" .. "\\\\ \\"" .. ';
 
-alert( str.match(reg) ); // "test me","Say \"Hello\"!","\\ \""
+alert( str.match(regexp) ); // "test me","Say \"Hello\"!","\\ \""
 ```

9-regular-expressions/13-regexp-alternation/03-match-quoted-string/task.md

@@ -1,32 +1,32 @@
-# 查询引用字符串
+# 查找引用的字符串
 
-构建一个正则表达式用于匹配双引号内的字符串 `subject:"..."`。
+构建一个正则表达式以查找双引号 `subject:"..."` 中的字符串。
 
-最重要的部分是字符串应该支持转义，正如 JavaScript 字符串的行为一样。例如，引号可以插入为 `subject:\"`，换行符为 `subject:\n`，斜杠本身为 `subject:\\`。
+字符串应该支持转义，就像 JavaScript 字符串一样。例如，引号可以插入为 `subject:\"`，换行符可以插入为 `subject:\n`，而反斜线本身可以插入为 `subject:\\`。
 
 ```js
 let str = "Just like \"here\".";
 ```
 
-对我们来说，重要的是转义的引号 `subject:\"` 不会结束字符串匹配。
+请注意，转义的引号 `subject:\"` 不会结束字符串匹配。
 
 所以，我们应该匹配两个引号之间的内容，且忽略中间转义的引号。
 
-这是任务的关键部分，否则这个任务就没什么意思了。
+这是任务的基本部分，否则这个任务就没什么意思了。
 
-匹配字符串示例：
+要匹配的字符串示例：
 ```js
 .. *!*"test me"*/!* ..  
-.. *!*"Say \"Hello\"!"*/!* ... (escaped quotes inside)
-.. *!*"\\"*/!* ..  (double slash inside)
-.. *!*"\\ \""*/!* ..  (double slash and an escaped quote inside)
+.. *!*"Say \"Hello\"!"*/!* ..（其中有被转义的引号）
+.. *!*"\\"*/!* ..（其中有双反斜线）
+.. *!*"\\ \""*/!* ..（其中有双反斜线和被转义的引号）
 ```
 
-在 JavaScript 中，双斜杠用于把斜杠转义为字符串，如下所示：
+在 JavaScript 中，双反斜线用于把反斜线转义为字符串，如下所示：
 
 ```js run
 let str = ' .. "test me" .. "Say \\"Hello\\"!" .. "\\\\ \\"" .. ';
 
-// the in-memory string
+// 存储中的字符串
 alert(str); //  .. "test me" .. "Say \"Hello\"!" .. "\\ \"" ..
 ```

9-regular-expressions/13-regexp-alternation/04-match-exact-tag/solution.md

@@ -1,16 +1,16 @@
 
-模式的开头显而易见：`pattern:<style`。
+模式的开头很明显：`pattern:<style`。
 
-...然而不能简单地写出 `pattern:<style.*?>` 这样的表达式，因为会同时匹配 `match:<styler>`。
+……但我们不能简单地将表达式写为 `pattern:<style.*?>`，因为会匹配上 `match:<styler>`。
 
-要么匹配 `match:<style` 后的一个空格，然后匹配任意内容；要么直接匹配结束符号 `match:>`。
+我们要匹配的是在 `match:<style` 之后紧跟着一个空格然后是可选的其他内容，或者直接是闭标签 `match:>`。
 
-最终的正则表达式为：`pattern:<style(>|\s.*?>)`。
+写成正则表达式即为：`pattern:<style(>|\s.*?>)`。
 
-运行代码如下：
+代码运行如下：
 
 ```js run
-let reg = /<style(>|\s.*?>)/g;
+let regexp = /<style(>|\s.*?>)/g;
 
-alert( '<style> <styler> <style test="...">'.match(reg) ); // <style>, <style test="...">
+alert( '<style> <styler> <style test="...">'.match(regexp) ); // <style>, <style test="...">
 ```

9-regular-expressions/13-regexp-alternation/04-match-exact-tag/task.md

@@ -1,13 +1,13 @@
 # 查找完整标签
 
-写出一个正则表达式，用于查找 `<style...>` 标签。它应该匹配完整的标签：该标签可能是没有属性的标签 `<style>` 或是有很多属性的标签 `<style type="..." id="...">`。
+写出一个正则表达式，用于查找 `<style...>` 标签。它应该匹配完整的标签：该标签可能没有特性（attributes）`<style>`，也可能有很多特性 `<style type="..." id="...">`。
 
-...同时正则表达式不应该匹配 `<styler>`！
+……同时正则表达式不应该匹配 `<styler>`！
 
-举例如下：
+例如：
 
 ```js
-let reg = /your regexp/g;
+let regexp = /你的正则表达式/g;
 
-alert( '<style> <styler> <style test="...">'.match(reg) ); // <style>, <style test="...">
+alert( '<style> <styler> <style test="...">'.match(regexp) ); // <style>, <style test="...">
 ```

9-regular-expressions/13-regexp-alternation/article.md

@@ -1,70 +1,70 @@
-# 选择（OR）|
+# 选择 (OR) |
 
 选择是正则表达式中的一个术语，实际上是一个简单的“或”。
 
 在正则表达式中，它用竖线 `pattern:|` 表示。
 
-例如，我们需要找出编程语言：HTML、PHP、Java 或 JavaScript。
+例如，我们想要找出编程语言：HTML、PHP、Java 或 JavaScript。
 
 对应的正则表达式为：`pattern:html|php|java(script)?`。
 
 用例如下：
 
 ```js run
-let reg = /html|php|css|java(script)?/gi;
+let regexp = /html|php|css|java(script)?/gi;
 
 let str = "First HTML appeared, then CSS, then JavaScript";
 
-alert( str.match(reg) ); // 'HTML', 'CSS', 'JavaScript'
+alert( str.match(regexp) ); // 'HTML', 'CSS', 'JavaScript'
 ```
 
-我们已知的一个相似符号 —— 方括号。就允许在许多字符中进行选择，例如 `pattern:gr[ae]y` 匹配 `match:gray` 或 `match:grey`。
+我们看到过类似的东西 —— 方括号。它允许我们在多个字符中进行选择，例如 `pattern:gr[ae]y` 匹配 `match:gray` 或 `match:grey`。
 
-选择符号并非在字符级别生效，而是在表达式级别。正则表达式 `pattern:A|B|C` 意思是命中 `A`、`B` 或 `C` 其一均可。
+方括号只允许字符或字符类。选择允许任何表达式。正则表达式 `pattern:A|B|C` 表示表达式 `A`、`B` 或 `C` 其一均可。
 
 例如：
 
-- `pattern:gr(a|e)y` 严格等同 `pattern:gr[ae]y`。
-- `pattern:gra|ey` 匹配 "gra" or "ey"。
+- `pattern:gr(a|e)y` 等同于 `pattern:gr[ae]y`。
+- `pattern:gra|ey` 表示 `match:gra` 或 `match:ey`。
 
-我们通常用圆括号把模式中的选择部分括起来，像这样 `pattern:before(XXX|YYY)after`。
+要将选择应用于模式中一部分内容的选择，我们可以将其括在括号中：
+- `pattern:I love HTML|CSS` 匹配 `match:I love HTML` 或 `match:CSS`。
+- `pattern:I love (HTML|CSS)` 匹配 `match:I love HTML` 或 `match:I love CSS`。
 
-## 时间正则表达式
+## 示例：用于时间匹配的正则表达式
 
-在之前的章节中有个任务是构建用于查找形如 `hh:mm` 的时间字符串，例如 `12:00`。但是简单的 `pattern:\d\d:\d\d` 过于模糊。它同时匹配 `25:99`。
+在之前的章节中有个任务是构建用于查找形如 `hh:mm` 的时间字符串，例如 `12:00`。但是简单的 `pattern:\d\d:\d\d` 太模糊了。它也会匹配 `25:99`（因为 25 和 99 都与模式匹配，但这不是有效的时间）。
 
-如何构建更优的正则表达式？
+如何构建更好的模式？
 
-我们可以应用到更多的严格匹配结果中：
+我们可以应用更精细的匹配。首先，对于时间：
 
-- 首个匹配数字必须是 `0` 或 `1`，同时其后还要跟随任一数字。
-- 或者是数字 `2` 之后跟随 `pattern:[0-3]`。
+- 如果第一位数是 `0` 或 `1`，那么下一位数可以是任何数值：`pattern:[01]\d`。
+- 否则，如果第一位数是 `2`，那么下一位数必须是 `pattern:[0-3]`。
+- 不允许其他的首位数。
 
-构建正则表达式：`pattern:[01]\d|2[0-3]`。
+我们可以使用选择在正则表达式中编写这两种变体：`pattern:[01]\d|2[0-3]`。
 
-接着可以添加冒号和分钟的部分。
+接下来，分钟必须为从 `00` 到 `59` 的数。写成正则表达式即为 `pattern:[0-5]\d`：第一个数字 `0-5`，然后是任何数字。
 
-分钟的部分必须在 `0` 到 `59` 区间，在正则表达式语言中含义为首个匹配数字 `pattern:[0-5]` 其后跟随任一数字 `\d`。
+如果我们将小时和分钟的正则表达式组合在一起，我们会得到：`pattern:[01]\d|2[0-3]:[0-5]\d`
 
-把它们拼接在一起形成最终的模式 `pattern:[01]\d|2[0-3]:[0-5]\d`。
+我们差不多完成了，但有一个问题。选择 `pattern:|` 现在恰好位于 `pattern:[01]\d` 和 `pattern:2[0-3]:[0-5]\d` 之间。
 
-快大功告成了，但仍然存在一个问题。选择符 `|` 在 `pattern:[01]\d` 和 `pattern:2[0-3]:[0-5]\d` 之间。这是错误的，因为它只匹配符号左侧或右侧任一表达式。
+也就是说：它只匹配符号左侧或右侧任一表达式。
 
-
-```js run
-let reg = /[01]\d|2[0-3]:[0-5]\d/g;
-
-alert("12".match(reg)); // 12 (matched [01]\d)
+```
+[01]\d  |  2[0-3]:[0-5]\d
 ```
 
-这个错误相当明显，但也是初学正则表达式的常见错误。
+此模式查找 `pattern:[01]\d` 或 `pattern:2[0-3]:[0-5]\d`。
 
-我们需要添加一个插入语用于匹配时钟：`[01]\d` 或 `2[0-3]`。
+但这是错误的，应该只在正则表达式的“小时”部分使用选择，以允许 `pattern:[01]\d` 或 `pattern:2[0-3]`。让我们通过将“小时”括在括号中来纠正这个问题：`pattern:([01]\d|2[0-3]):[0-5]\d`
 
-以下为正确版本：
+最终的解决方案：
 
 ```js run
-let reg = /([01]\d|2[0-3]):[0-5]\d/g;
+let regexp = /([01]\d|2[0-3]):[0-5]\d/g;
 
-alert("00:00 10:10 23:59 25:99 1:2".match(reg)); // 00:00,10:10,23:59
+alert("00:00 10:10 23:59 25:99 1:2".match(regexp)); // 00:00,10:10,23:59
 ```