feat: update translation

Author: leviding

9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/solution.md

@@ -1,9 +1,9 @@
 
-Solution:
+答案：
 
 ```js run
-let reg = /\.{3,}/g;
-alert( "Hello!... How goes?.....".match(reg) ); // ..., .....
+let regexp = /\.{3,}/g;
+alert( "Hello!... How goes?.....".match(regexp) ); // ..., .....
 ```
 
-需要注意的是，点号（.）是一个特殊字符，因此我们需要将其转义并作为 `\.` 插入语句。
+请注意，点（.）是一个特殊字符，所以我们必须对其进行转义，即将其插入为 `\.`。

9-regular-expressions/09-regexp-quantifiers/1-find-text-manydots/task.md

@@ -9,6 +9,6 @@ importance: 5
 例如：
 
 ```js
-let reg = /你的正则表达式/g;
-alert( "Hello!... How goes?.....".match(reg) ); // ..., .....
+let regexp = /你的正则表达式/g;
+alert( "Hello!... How goes?.....".match(regexp) ); // ..., .....
 ```

9-regular-expressions/09-regexp-quantifiers/2-find-html-colors-6hex/solution.md

@@ -1,17 +1,17 @@
-我们需要寻找 `#` 字符，后跟六个十六进制字符。
+我们需要寻找首个字符是 `#`，后面紧接着的是六位的十六进制字符的匹配项。
 
-一个十六进制字符可以被描述为 `pattern:[0-9a-fA-F]`。如果我们使用 `i` 标识，那么只需要 `pattern:[0-9a-f]`。
+一个十六进制字符可以描述为 `pattern:[0-9a-fA-F]`。如果我们使用修饰符 `i`，那么只需要 `pattern:[0-9a-f]`。
 
-然后我们可以用量词 `pattern:{6}` 来查找这六个。
+然后我们可以使用量词 `pattern:{6}` 来查找其 6 个字符。
 
-因此，我们得到正则表达式：`pattern:/#[a-f0-9]{6}/gi`。
+那么，我们得到正则表达式：`pattern:/#[a-f0-9]{6}/gi`。
 
 ```js run
-let reg = /#[a-f0-9]{6}/gi;
+let regexp = /#[a-f0-9]{6}/gi;
 
 let str = "color:#121212; background-color:#AA00ef bad-colors:f#fddee #fd2"
 
-alert( str.match(reg) );  // #121212,#AA00ef
+alert( str.match(regexp) );  // #121212,#AA00ef
 ```
 
 问题是其从更长的序列中匹配了颜色值：
@@ -23,9 +23,9 @@ alert( "#12345678".match( /#[a-f0-9]{6}/gi ) ) // #123456
 为了解决这个问题，我们可以在末尾加上 `pattern:\b`：
 
 ```js run
-// color
+// 颜色值
 alert( "#123456".match( /#[a-f0-9]{6}\b/gi ) ); // #123456
 
-// not a color
+// 不是颜色值
 alert( "#12345678".match( /#[a-f0-9]{6}\b/gi ) ); // null
 ```

9-regular-expressions/09-regexp-quantifiers/2-find-html-colors-6hex/task.md

@@ -1,15 +1,15 @@
 # 针对 HTML 颜色的正则表达式
 
-创建一个正则表达式来搜寻格式为 `#ABCDEF` 的 HTML 颜色值：首个字符 `#` 以及接下来的六位十六进制字符。
+创建一个正则表达式来查找格式为 `#ABCDEF` 的 HTML 颜色值：首个字符是 `#`，后面紧接着的是六位的十六进制字符。
 
-一个例子：
+用例：
 
 ```js
-let reg = /...你的正则表达式.../
+let regexp = /...你的正则表达式.../
 
 let str = "color:#121212; background-color:#AA00ef bad-colors:f#fddee #fd2 #12345678";
 
-alert( str.match(reg) )  // #121212,#AA00ef
+alert( str.match(regexp) )  // #121212,#AA00ef
 ```
 
-P.S. 在这个任务中，我们不需要其他的颜色格式，比如 `#123` 或 `rgb(1,2,3)` 等。
+P.S. 在这个任务中，我们不需要其他的颜色格式，例如 `#123` 或 `rgb(1,2,3)` 等。

9-regular-expressions/09-regexp-quantifiers/article.md

@@ -1,40 +1,46 @@
-# 量词 `+,*,?` 和 `{n}`
+# 量词 +, *, ? 和 {n}
 
-假设我们有一个字符串 `+7(903)-123-45-67`，并且想要找到它包含的所有数字。但与之前不同的是，我们对单个数字不感兴趣，只对全数感兴趣：`7, 903, 123, 45, 67`。
+假设我们有一个像这样 `+7(903)-123-45-67` 的字符串，并想要找到其中所有数字。但与之前不同的是，我们对单个数字不感兴趣，只对全数感兴趣：`7, 903, 123, 45, 67`。
 
-数字是一个或多个 `\d` 的序列。用来形容我们所需要的数量的词被称为**量词**。
+数字是一个或多个数字 `pattern:\d` 的序列。为了标记我们需要的数量，我们需要加一个 **量词**。
 
 ## 数量 {n}
 
-最明显的量词便是一对引号间的数字：`pattern:{n}`。在一个字符（或一个字符类等等）后跟着一个量词，用来指出我们具体需要的数量。
+最简单的量词便是大括号中的数字：`pattern:{n}`。
 
-它有更高级的格式，用一个例子来说明：
+在一个字符（或一个字符类，或 `[...]` 等）后附加一个量词，用来指出我们具体需要的数量。
 
-确切的位数：`{5}`
-: `pattern:\d{5}` 表示 5 位的数字，如同 `pattern:\d\d\d\d\d`。
+它有一些高级的形式，让我们看一些例子：
 
-    接下来的例子将会查找一个五位数的数字：
+确切的位数：`pattern:{5}`
+: `pattern:\d{5}` 表示 5 位数，与 `pattern:\d\d\d\d\d` 相同。
+
+    下面这个例子查找一个五位数的数字：
 
     ```js run
     alert( "I'm 12345 years old".match(/\d{5}/) ); //  "12345"
     ```
 
-    我们可以添加 `\b` 来排除更多位数的数字：`pattern:\b\d{5}\b`。
+    我们可以添加 `\b` 来排除位数更多的数字：`pattern:\b\d{5}\b`。
 
-某个范围的位数：`{3,5}`
-: 我们可以将限制范围的数字放入括号中，来查找位数为 3 至 5 位的数字：`pattern:\d{3,5}`
+范围：`pattern:{3,5}`，匹配 3-5 个
+: 要查找 3-5 位的数字，我们可以将限制写在花括号中：`pattern:\d{3,5}`
 
     ```js run
     alert( "I'm not 12, but 1234 years old".match(/\d{3,5}/) ); // "1234"
     ```
 
-    我们可以省略上限。那么正则表达式 `pattern:\d{3,}` 就会查找位数大于或等于 3 的数字：
+    我们可以省略上限。
+    
+    那么正则表达式 `pattern:\d{3,}` 就会查找位数大于等于 `3` 的数字：
 
     ```js run
     alert( "I'm not 12, but 345678 years old".match(/\d{3,}/) ); // "345678"
     ```
 
-对于字符串 `+7(903)-123-45-67` 来说，我们如果需要一个或多个连续的数字，就使用 `pattern:\d{1,}`：
+让我们回到字符串 `+7(903)-123-45-67`。
+
+我们如果需要一个及以上的数字，就使用 `pattern:\d{1,}`：
 
 ```js run
 let str = "+7(903)-123-45-67";
@@ -46,10 +52,10 @@ alert(numbers); // 7,903,123,45,67
 
 ## 缩写
 
-大多数常用的量词都可以有缩写：
+大多数常用的量词都有简写形式：
 
-`+`
-: 代表“一个或多个”，相当于 `{1,}`。
+`pattern:+`
+: 代表“一个或多个”，与 `pattern:{1,}` 相同。
 
     例如，`pattern:\d+` 用来查找所有数字：
 
@@ -59,75 +65,78 @@ alert(numbers); // 7,903,123,45,67
     alert( str.match(/\d+/g) ); // 7,903,123,45,67
     ```
 
-`?`
-: 代表“零个或一个”，相当于 `{0,1}`。换句话说，它使得符号变得可选。
+`pattern:?`
+: 代表“零个或一个”，与 `pattern:{0,1}` 相同。换句话说，它使得符号变得可选。
 
     例如，模式 `pattern:ou?r` 查找 `match:o`，后跟零个或一个 `match:u`，然后是 `match:r`。
 
-    所以他能够在 `subject:color` 中找到 `match:or`，以及在 `subject:colour` 中找到 `match:our`：
+    所以 `pattern:colou?r` 会找到 `match:color` 和 `match:colour`：
 
     ```js run
     let str = "Should I write color or colour?";
 
     alert( str.match(/colou?r/g) ); // color, colour
     ```
 
-`*`
-: 代表着“零个或多个”，相当于 `{0,}`。也就是说，这个字符可以多次出现或不出现。
+`pattern:*`
+: 代表“零个及以上”，与 `{0,}` 相同。也就是说，字符可以出现任何次数或者不出现。
 
-    接下来的例子将要寻找一个后跟任意数量的 0 的数字：
+    例如，`pattern:\d0*` 查找一个数字后面跟着任意数量的零（可能有很多或没有）的数字：
 
     ```js run
     alert( "100 10 1".match(/\d0*/g) ); // 100, 10, 1
     ```
 
-    将它与 `'+'`（一个或多个）作比较：
+    将其与 `pattern:+`（一个或更多）做比较：
 
     ```js run
     alert( "100 10 1".match(/\d0+/g) ); // 100, 10
+    // 1 没有被匹配出来，因为 0+ 要求至少有一个 0
     ```
 
 ## 更多示例
 
-量词是经常被使用的。它们是构成复杂的正则表达式的主要模块之一，我们接着来看更多的例子。
+量词是很常用的。它们是构成复杂正则表达式的主要“模块”，所以让我们看更多示例。
 
-正则表达式“浮点数”（带浮点的数字）：`pattern:\d+\.\d+`
-: 实现：
-    ```js run
-    alert( "0 1 12.345 7890".match(/\d+\.\d+/g) ); // 12.345
-    ```
+小数的正则表达式（带浮点的数字）：`pattern:\d+\.\d+`
+
+实现：
+```js run
+alert( "0 1 12.345 7890".match(/\d+\.\d+/g) ); // 12.345
+```
 
-正则表达式“打开没有属性的 HTML 标记”，比如 `<span>` 或 `<p>`：`pattern:/<[a-z]+>/i`
-: 实现：
+”没有特性（attribute）的打开的 HTML 标签（例如 `<span>` 或 `<p>`）“的正则表达式。
+
+1. 最简单的：`pattern:/<[a-z]+>/i`
 
     ```js run
     alert( "<body> ... </body>".match(/<[a-z]+>/gi) ); // <body>
     ```
 
-    我们查找字符 `pattern:'<'` 后跟一个或多个英文字母，然后是 `pattern:'>'`。
+    正则表达式查找的匹配项是字符 `pattern:'<'` 后跟一个或多个拉丁字母，然后是 `pattern:'>'`。
+
+2. 进阶版：`pattern:/<[a-z][a-z0-9]*>/i`
 
-正则表达式“打开没有属性的HTML标记”（改进版）：`pattern:/<[a-z][a-z0-9]*>/i`
-: 更好的表达式：根据标准，HTML 标记名称可以在除了第一个位置以外的任意一个位置有一个数字，比如 `<h1>`。
+根据标准，HTML 标签名称可以在除了第一个位置之外的任何位置有一个数字，例如 `<h1>`。
 
     ```js run
     alert( "<h1>Hi!</h1>".match(/<[a-z][a-z0-9]*>/gi) ); // <h1>
     ```
 
-正则表达式“打开没有属性的HTML标记”：`pattern:/<\/?[a-z][a-z0-9]*>/i`
-: 我们在标记前加上了一个可选的斜杆 `pattern:/?`。必须用一个反斜杠来转义它，否则 JavaScript 就会认为它是这个模式的结束符。
+**“打开或关闭的不带特性的 HTML 标签”的正则表达式：`pattern:/<\/?[a-z][a-z0-9]*>/i`**
 
-    ```js run
-    alert( "<h1>Hi!</h1>".match(/<\/?[a-z][a-z0-9]*>/gi) ); // <h1>, </h1>
-    ```
+我们在模式开头附近添加了一个可选的斜杠 `pattern:/?`。必须用一个反斜杠转义它，否则 JavaScript 会认为它是这个模式的结束符。
 
-```smart header="更精确意味着更复杂"
-我们能够从这些例子中看到一个共同的规则：正则表达式越精确 —— 它就越长且越复杂。
+```js run
+alert( "<h1>Hi!</h1>".match(/<\/?[a-z][a-z0-9]*>/gi) ); // <h1>, </h1>
+```
 
-例如，HTML 标记能用一个简单的正则表达式：`pattern:<\w+>`。
+```smart header="为了使正则表达式更精确，我们通常需要使其更复杂"
+我们能够从这些例子中看到一个共同的规则：正则表达式越精确 —— 它就越长越复杂。
 
-因为 `pattern:\w` 代表任意英文字母或数字或 `'_'`，这个正则表达式也能够匹配非标注的内容，比如 `match:<_>`。但它要比 `pattern:<[a-z][a-z0-9]*>` 简单很多。
+例如，对于 HTML 标签，我们可以使用更简单的正则表达式：`pattern:<\w+>`。但是由于 HTML 对标签名称有更严格的限制，所以 `pattern:<[a-z][a-z0-9]*>` 更可靠
 
-我们能够接受 `pattern:<\w+>` 或者我们需要 `pattern:<[a-z][a-z0-9]*>`？
+我们可以使用 `pattern:<\w+>` 还是需要 `pattern:<[a-z][a-z0-9]*>`？
 
-在现实生活中，两种方式都能接受。取决于我们对于“额外”匹配的宽容程度以及是否难以通过其他方式来过滤掉它们。
+在实际开发中，这两种变体都是可以接受的。具体用哪个取决于我们对于“额外”匹配的宽容程度，以及通过其他方式将它们从结果中删除的困难程度。
 ```