feat: update translation

Author: leviding

9-regular-expressions/11-regexp-groups/01-test-mac/solution.md

@@ -4,7 +4,7 @@
 
 所以正则表达式为：`pattern:[0-9a-f]{2}(:[0-9a-f]{2}){5}`
 
-现在让我们验证一下此匹配规则可以捕获整个文本：从开头开始，在结尾结束。这是通过将模式（pattern）包装在 `pattern:^...$` 中实现的。
+现在让我们验证一下此匹配规则可以捕获整个文本：从开头开始，在结尾结束。这是通过将模式包装在 `pattern:^...$` 中实现的。
 
 最终：
 

9-regular-expressions/11-regexp-groups/01-test-mac/task.md

@@ -4,7 +4,7 @@
 
 例如：`subject:'01:32:54:67:89:AB'`。
 
-编写一个检查一个字符串是否为 MAC 地址的正则表达式。
+编写一个检查字符串是否为 MAC 地址的正则表达式。
 
 用例：
 ```js

9-regular-expressions/11-regexp-groups/02-find-webcolor-3-or-6/solution.md

@@ -1,8 +1,8 @@
 查找 `#` 号后跟着 3 位十六进制数的颜色值 `#abc` 的正则表达式：`pattern:/#[a-f0-9]{3}/i`。
 
-我们可以再添加 3 位可选的十六进制数字。这样刚好，不多不少。只匹配 `#` 号后跟着 3 位 或 6 位十六进制数字的颜色值。
+我们可以再添加 3 位可选的十六进制数字。这样刚好，不多不少。只匹配 `#` 号后跟着 3 位或 6 位十六进制数字的颜色值。
 
-我们使用量词（quantifier）`pattern:{1,2}` 来实现：所以正则表达式为 `pattern:/#([a-f0-9]{3}){1,2}/i`。
+我们使用量词 `pattern:{1,2}` 来实现：所以正则表达式为 `pattern:/#([a-f0-9]{3}){1,2}/i`。
 
 这里将模式 `pattern:[a-f0-9]{3}` 用括号括起来，以在其外面应用量词 `pattern:{1,2}`。
 

9-regular-expressions/11-regexp-groups/04-parse-expression/solution.md

@@ -1,4 +1,4 @@
-一个数字的正则表达式：`pattern:-?\d+(\.\d+)?`。我们在上一题中创建了这个表达式。
+匹配数字的正则表达式：`pattern:-?\d+(\.\d+)?`。我们在上一题创建了这个表达式。
 
 我们可以使用 `pattern:[-+*/]` 匹配运算符。连字符 `pattern:-` 在方括号中的最前面，因为在中间它表示字符范围，而我们只想让其表示字符 `-`。
 
@@ -23,20 +23,20 @@ let regexp = /(-?\d+(\.\d+)?)\s*([-+*\/])\s*(-?\d+(\.\d+)?)/;
 alert( "1.2 + 12".match(regexp) );
 ```
 
-结果包含：
+结果包括：
 
-- `result[0] == "1.2 + 12"` (完全匹配)
+- `result[0] == "1.2 + 12"` (完整的匹配项)
 - `result[1] == "1.2"` (第一组 `(-?\d+(\.\d+)?)` —— 第一个数字，包括小数部分)
 - `result[2] == ".2"` (第二组 `(\.\d+)?` —— 第一个数字的小数部分)
 - `result[3] == "+"` (第三组 `([-+*\/])` —— 运算符)
 - `result[4] == "12"` (第四组 `(-?\d+(\.\d+)?)` —— 第二个数字)
 - `result[5] == undefined`（第五组 `(\.\d+)?` —— 第二个数字的小数部分不存在，所以这里是 undefined）
 
-我们只想要数字和运算符，不需要没有完全匹配的以及小数部分结果，所以让我们稍微“清理”一下结果。
+我们只想要数字和运算符，不需要完全匹配的以及小数部分结果，所以让我们稍微“清理”一下结果。
 
 我们可以使用数组的 `shift` 方法 `result.shift()` 来删去完全匹配的结果（数组的第一项）。
 
-可以通过在开头 `pattern:(?:\.\d+)?` 添加 `pattern:?:` 来排除包含小数部分的组（第 2 和第 4 个）`pattern:(.\d+)` 可以通过。
+可以通过在开头添加 `pattern:?:` 来排除包含小数部分（数字 2 和 4）`pattern:(.\d+)` 的组：`pattern:(?:\.\d+)?`。
 
 最终的解决方案：
 

9-regular-expressions/11-regexp-groups/04-parse-expression/task.md

@@ -7,7 +7,7 @@
 - `-3 / -6`
 - `-2 - 2`
 
-运算符为 `"+"`、`"-"`、`"*"` 和 `"/"` 中之一。
+运算符为 `"+"`、`"-"`、`"*"` 或 `"/"` 中之一。
 
 在开头、之间的部分或末尾可能有额外的空格。
 

9-regular-expressions/11-regexp-groups/article.md

@@ -1,6 +1,6 @@
 # 捕获组
 
-模式的一部分可以用括号括起来 `pattern:(...)`。这称为“捕获组（capturing group）”。
+模式的一部分可以用括号括起来 `pattern:(...)`。这被称为“捕获组（capturing group）”。
 
 这有两个影响：
 
@@ -43,15 +43,15 @@ let regexp = /(\w+\.)+\w+/g;
 alert( "site.com my.site.com".match(regexp) ); // site.com,my.site.com
 ```
 
-搜索有效，但是该模式无法匹配带有连字符的域名，例如 my-site.com，因为连字符不属于 `pattern:\w` 类。
+搜索有效，但该模式无法匹配带有连字符的域名，例如 my-site.com，因为连字符不属于 `pattern:\w` 类。
 
-我们可以通过用 `pattern:[\w-]` 替换 `pattern:\w` 来匹配除最后一个的每个单词：`pattern:([\w-]+\.)+\w+`。
+我们可以通过用 `pattern:[\w-]` 替换 `pattern:\w` 来匹配除最后一个单词以外的每个单词：`pattern:([\w-]+\.)+\w+`。
 
-### 示例：email
+### 示例：电子邮件
 
-前面的示例可以扩展。我们可以基于它为电子邮件创建一个正则表达式。
+扩展一下上面这个示例。我们可以基于它为电子邮件创建一个正则表达式。
 
-email 格式为：`name@domain`。名称可以是任何单词，可以使用连字符和点。在正则表达式中为 `pattern:[-.\w]+`。
+电子邮件的格式为：`name@domain`。名称可以是任何单词，允许使用连字符和点。在正则表达式中为 `pattern:[-.\w]+`。
 
 模式：
 
@@ -61,24 +61,24 @@ let regexp = /[-.\w]+@([\w-]+\.)+[\w-]+/g;
 alert("my@mail.com @ his@site.com.uk".match(regexp)); // my@mail.com, his@site.com.uk
 ```
 
-该正则表达式并不完美的，但多数情况下都可以工作，并且有助于修复意外的错误类型。唯一真正可靠的 email 检查只能通过发送 email 来完成。
+该正则表达式并不完美的，但多数情况下都能正确匹配，并且有助于修复输入邮箱时的意外错误输入。唯一真正可靠的电子邮件检查只能通过发送电子邮件来完成。
 
-## 匹配括号中的内容
+## 匹配中的括号的内容
 
-括号从左到右编号。正则引擎会记住它们各自匹配的内容，并允许在结果中获得它。
+括号被从左到右编号。正则引擎会记住它们各自匹配的内容，并允许在结果中获取它。
 
-方法 `str.match(regexp)`，如果 `regexp` 没有 `g` 标志，将查找第一个匹配并将它作为一个数组返回：
+方法 `str.match(regexp)`，如果 `regexp` 没有修饰符 `g`，将查找第一个匹配项，并将它作为数组返回：
 
-1. 在索引 `0` 处：完全匹配。
+1. 在索引 `0` 处：完整的匹配项。
 2. 在索引 `1` 处：第一个括号的内容。
 3. 在索引 `2` 处：第二个括号的内容。
-4. …等等…
+4. ……等等……
 
-例如，我们想找到 HTML 标记 `pattern:<.*?>` 并进行处理。这将很方便的把标签内容（尖括号内的内容）放在单独的变量中。
+例如，我们想找到 HTML 标签 `pattern:<.*?>` 并处理它们。将标签内容（尖括号内的内容）放在单独的变量中会很方便。
 
 让我们将内部内容包装在括号中，像这样：`pattern:<(.*?)>`。
 
-现在，我们能在结果数组中获取标签的整体 `match:<h1>` 及其内容 `match:h1`：
+现在，我们在结果数组中得到了标签的整体 `match:<h1>` 及其内容 `match:h1`：
 
 ```js run
 let str = '<h1>Hello, world!</h1>';
@@ -93,19 +93,19 @@ alert( tag[1] ); // h1
 
 括号可以嵌套。在这种情况下，编号也从左到右。
 
-例如，在搜索标签 `subject:<span class="my">` 时我们可能会对以下内容感兴趣：
+例如，在搜索标签 `subject:<span class="my">` 时，我们可能会对以下内容感兴趣：
 
-1. 整个标签内容：`match:span class="my"`。
+1. 整个标签的内容：`match:span class="my"`。
 2. 标签名称：`match:span`。
-3. 标签属性：`match:class="my"`。
+3. 标签特性：`match:class="my"`。
 
 让我们为它们添加括号：`pattern:<(([a-z]+)\s*([^>]*))>`。
 
-这是它们的编号方式（从左到右，由左括号开始）：
+这是它们的编号方式（根据左括号从左到右）：
 
 ![](regexp-nested-groups-pattern.svg)
 
-实际上：
+验证：
 
 ```js run
 let str = '<span class="my">';
@@ -119,57 +119,57 @@ alert(result[2]); // span
 alert(result[3]); // class="my"
 ```
 
-`result` 的零索引始终保持完全匹配。
+`result` 的索引 0 中始终保存的是正则表达式的完整匹配项。
 
-然后按左括号将组从左到右编号。第一组返回为 `result[1]`。它包含了整个标签内容。
+然后是按左括号从左到右编号的组。第一组返回为 `result[1]`。它包含了整个标签内容。
 
-然后 `result[2]` 从第二个开始的括号中进入该组 `pattern:([a-z]+)` —— 标签名称，然后在 `result[3]` 标签中：`pattern:([^>]*)`。
+然后是 `result[2]`，从第二个左括号开始分组 `pattern:([a-z]+)` —— 标签名称，然后在 `result[3]` 中：`pattern:([^>]*)`。
 
 字符串中每个组的内容：
 
 ![](regexp-nested-groups-matches.svg)
 
 ### 可选组
 
-即使组是可选的并且在匹配项中不存在（例如，具有数量词 `pattern:(...)?`），也存在相应的 `result` 数组项，并且等于 `undefined`。
+即使组是可选的并且在匹配项中不存在（例如，具有量词 `pattern:(...)?`），也存在相应的 `result` 数组项，并且等于 `undefined`。
 
-例如，让我们考虑正则 `pattern:a(z)?(c)?`。它寻找 `"a"` ，然后是可选的 `"z"`，然后是可选的 `"c"`。
+例如，让我们考虑正则表达式 `pattern:a(z)?(c)?`。它查找 `"a"`，后面是可选的 `"z"`，然后是可选的 `"c"`。
 
 如果我们在单个字母的字符串上运行 `subject:a`，则结果为：
 
 ```js run
 let match = 'a'.match(/a(z)?(c)?/);
 
 alert( match.length ); // 3
-alert( match[0] ); // a（完全匹配）
+alert( match[0] ); // a（完整的匹配项）
 alert( match[1] ); // undefined
 alert( match[2] ); // undefined
 ```
 
 数组的长度为 `3`，但所有组均为空。
 
-这是字符串的一个更复杂的匹配 `subject:ac`：
+对字符串 `subject:ac` 的匹配会更复杂：
 
 ```js run
 let match = 'ac'.match(/a(z)?(c)?/)
 
 alert( match.length ); // 3
-alert( match[0] ); // ac（完全匹配）
-alert( match[1] ); // undefined，因为 (z)? 没匹配项
+alert( match[0] ); // ac（完整的匹配项）
+alert( match[1] ); // undefined, 因为没有 (z)? 的匹配项
 alert( match[2] ); // c
 ```
 
-数组长度是恒定的：`3`。但是对于组 `pattern:(z)?` 而言，什么都没有，所以结果是 `["ac", undefined, "c"]`。
+数组长度依然是：`3`。但没有组 `pattern:(z)?` 的匹配项，所以结果是 `["ac", undefined, "c"]`。
 
-## 搜索所有具有组的匹配项：matchAll
+## 带有组搜索所有匹配项：matchAll
 
 ```warn header="`matchAll` 是一个新方法，可能需要使用 polyfill"
 旧的浏览器不支持 `matchAll`。
 
-可能需要一个 polyfill，例如 <https://github.com/ljharb/String.prototype.matchAll>.
+可能需要进行 polyfill，例如 <https://github.com/ljharb/String.prototype.matchAll>.
 ```
 
-当我们搜索所有匹配项（标志 `pattern:g`）时，`match` 方法不会返回组的内容。
+当我们搜索所有匹配项（修饰符 `pattern:g`）时，`match` 方法不会返回组的内容。
 
 例如，让我们查找字符串中的所有标签：
 
@@ -185,31 +185,31 @@ alert( tags ); // <h1>,<h2>
 
 要获取它们，我们应该使用方法 `str.matchAll(regexp)` 进行搜索。
 
-在使用 `match` 很长一段时间后，它作为“新的改进版本”被加入到 JavaScript 中。
+在使用 `match` 很长一段时间后，它才被作为“新的改进版本”被加入到 JavaScript 中。
 
 就像 `match` 一样，它寻找匹配项，但有 3 个区别：
 
 1. 它返回的不是数组，而是一个可迭代的对象。
-2. 当标志 `pattern:g` 存在时，它将每个匹配组作为一个数组返回。
-3. 如果没有匹配项，则不返回 `null`，而是返回一个空的可迭代对象。
+2. 当存在修饰符 `pattern:g` 时，它将每个匹配项以包含组的数组的形式返回。
+3. 如果没有匹配项，则返回的不是 `null`，而是一个空的可迭代对象。
 
 例如：
 
 ```js run
 let results = '<h1> <h2>'.matchAll(/<(.*?)>/gi);
 
-// results - is not an array, but an iterable object
+// results —— 不是数组，而是一个迭代对象
 alert(results); // [object RegExp String Iterator]
 
 alert(results[0]); // undefined (*)
 
-results = Array.from(results); // let's turn it into array
+results = Array.from(results); // 让我们将其转换为数组
 
-alert(results[0]); // <h1>,h1 (1st tag)
-alert(results[1]); // <h2>,h2 (2nd tag)
+alert(results[0]); // <h1>,h1（第一个标签）
+alert(results[1]); // <h2>,h2（第二个标签）
 ```
 
-我们可以看到，第一个区别非常重要，如 `(*)` 行所示。我们无法获得 `results[0]` 的匹配内容，因为该对象是伪数组。我们可以使用 `Array.from` 把它变成一个真正的 `Array`。在 Iterable（可迭代对象）<info:iterable>一文中有关于伪数组和可迭代对象的更多详细信息。
+我们可以看到，第一个区别非常重要，如 `(*)` 行所示。我们无法获得 `results[0]` 的匹配项，因为该对象是伪数组。我们可以使用 `Array.from` 把它变成一个真正的 `Array`。在 <info:iterable> 一文中有关于伪数组和可迭代对象的更多详细内容。
 
 如果我们不需要遍历结果，则 `Array.from` 没有必要：
 
@@ -218,8 +218,8 @@ let results = '<h1> <h2>'.matchAll(/<(.*?)>/gi);
 
 for(let result of results) {
   alert(result);
-  // 第一个结果: <h1>,h1
-  // 第二个结果: <h2>,h2
+  // 第一个 alert：<h1>,h1
+  // 第二个：<h2>,h2
 }
 ```
 
@@ -229,7 +229,7 @@ for(let result of results) {
 let [tag1, tag2] = '<h1> <h2>'.matchAll(/<(.*?)>/gi);
 ```
 
-由 `matchAll` 所返回的每个匹配，其格式与不带标志 `pattern:g` 的 `match` 所返回的格式相同：它是一个具有额外的 `index`（字符串中的匹配索引）属性和 `input`（源字符串）的数组：
+`matchAll` 返回的每个匹配项，与不带修饰符 `pattern:g` 的 `match` 所返回的格式相同：具有额外 `index`（字符串中的匹配索引）属性和 `input`（源字符串）的数组：
 
 ```js run
 let results = '<h1> <h2>'.matchAll(/<(.*?)>/gi);
@@ -243,20 +243,20 @@ alert( tag1.input ); // <h1> <h2>
 ```
 
 ```smart header="为什么 `matchAll` 的结果是可迭代对象而不是数组？"
-为什么这个方法这样设计？原因很简单 — 为了优化。
+为什么这个方法这样设计？原因很简单 —— 为了优化。
 
-调用 `matchAll` 不会执行搜索。相反，它返回一个可迭代的对象，最初没有结果。每当我们对它进行迭代时才会执行搜索，例如在循环中。
+调用 `matchAll` 不会执行搜索。相反，它返回一个可迭代对象，最初没有结果。每次我们迭代它时才会执行搜索，例如在循环中。
 
-因此，这将根据需要找到尽可能多的结果，而不是全部。
+因此，这将根据需要找出尽可能多的结果，而不是全部。
 
-例如，文本中可能有 100 个匹配项，但是在一个 `for..of` 循环中，我们已经找到了 5 个匹配项，然后觉得足够了并做出一个 `break`。这时引擎就不会花时间查找其他 95 个匹配。
+例如，文本中可能有 100 个匹配项，但在一个 `for..of` 循环中，我们找到了 5 个匹配项，然后觉得足够了并做出一个 `break`。这时引擎就不会花时间查找其他 95 个匹配。
 ```
 
 ## 命名组
 
-用数字记录组很困难。对于简单模式，它是可行的，但对于更复杂的模式，计算括号很不方便。我们有一个更好的选择：给括号起个名字。
+用数字记录组很困难。对于简单的模式，它是可行的，但对于更复杂的模式，计算括号很不方便。我们有一个更好的选择：给括号命名。
 
-这是通过在开始括号之后立即放置 `pattern:?<name>` 来完成的。
+在左括号后紧跟着放置 `pattern:?<name>` 即可完成对括号的命名。
 
 例如，让我们查找 "year-month-day" 格式的日期：
 
@@ -273,11 +273,11 @@ alert(groups.month); // 04
 alert(groups.day); // 30
 ```
 
-如您所见，匹配的组在 `.groups` 属性中。
+正如你所看到的，匹配的组在 `.groups` 属性中。
 
-要查找所有日期，我们可以添加标志 `pattern:g`。
+要查找所有日期，我们可以添加修饰符 `pattern:g`。
 
-我们还需要 `matchAll` 获取完整的组匹配：
+我们还需要 `matchAll` 以获取完整的组匹配：
 
 ```js run
 let dateRegexp = /(?<year>[0-9]{4})-(?<month>[0-9]{2})-(?<day>[0-9]{2})/g;
@@ -295,9 +295,9 @@ for(let result of results) {
 }
 ```
 
-## 替换捕获组
+## 替换中的捕获组
 
-方法 `str.replace(regexp, replacement)` 用 `replacement` 替换 `str` 中匹配 `regexp` 的所有捕获组。这使用 `pattern:$n` 来完成，其中 `pattern:n` 是组号。
+让我们能够替换 `str` 中 `regexp` 的所有匹配项的方法 `str.replace(regexp, replacement)` 允许我们在 `replacement` 字符串中使用括号中的内容。这使用 `pattern:$n` 来完成，其中 `pattern:n` 是组号。
 
 例如，
 
@@ -308,7 +308,7 @@ let regexp = /(\w+) (\w+)/;
 alert( str.replace(regexp, '$2, $1') ); // Bull, John
 ```
 
-对于命名括号，引用为 `pattern:$<name>`。
+对于命名的括号，引用为 `pattern:$<name>`。
 
 例如，让我们将日期格式从 "year-month-day" 更改为 "day.month.year"：
 
@@ -323,7 +323,7 @@ alert( str.replace(regexp, '$<day>.$<month>.$<year>') );
 
 ## 非捕获组 ?:
 
-有时我们需要括号才能正确应用量词，但我们不希望它们的内容出现在结果中。
+有时我们需要用括号才能正确应用量词，但我们不希望它们的内容出现在结果中。
 
 可以通过在开头添加 `pattern:?:` 来排除组。
 
@@ -341,24 +341,24 @@ let regexp = /(?:go)+ (\w+)/i;
 
 let result = str.match(regexp);
 
-alert( result[0] ); // Gogogo John（完全匹配）
+alert( result[0] ); // Gogogo John（完整的匹配项）
 alert( result[1] ); // John
-alert( result.length ); // 2（数组中没有更多项）
+alert( result.length ); // 2（在数组中没有其他数组项）
 ```
 
 ## 总结
 
-括号将正则表达式的一部分组合在一起，以便量词可以整体应用。
+括号将正则表达式中的一部分组合在一起，以便量词可以整体应用。
 
 括号组从左到右编号，可以选择用 `(?<name>...)` 命名。
 
 可以在结果中获得按组匹配的内容：
 
-* 方法 `str.match` 仅当不带标志 `pattern:g` 时返回捕获组。
+* 方法 `str.match` 仅当不带修饰符 `pattern:g` 时返回捕获组。
 * 方法 `str.matchAll` 始终返回捕获组。
 
 如果括号没有名称，则匹配数组按编号提供其内容。命名括号还可使用属性 `groups`。
 
-我们还可以使用 `str.replace` 来替换括号内容中的字符串：使用 `$n` 或者名称 `$<name>`。
+我们还可以在 `str.replace` 的替换字符串中使用括号内容：通过数字 `$n` 或者=名称 `$<name>`。
 
-可以通过在组的开头添加 `pattern:?:` 来排除编号组。当我们需要对整个组应用量词，但不希望将其作为结果数组中的单独项时这很有用。我们也不能在替换字符串时引用此类括号。
+可以通过在组的开头添加 `pattern:?:` 来排除编号。当我们需要对整个组应用量词，但不希望将其作为结果数组中的单独项时这很有用。我们也不能在替换字符串中引用这样的括号。