From 86901f51cbb6294053107c1371d7a1cfc70bd2cc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E6=B1=89=E7=A5=A5?= <l945457758@gmail.com>
Date: Wed, 12 Sep 2018 18:16:20 +0800
Subject: [PATCH 01/16] solution

---
 .../07-regexp-quantifiers/1-find-text-manydots/solution.md    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/solution.md b/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/solution.md
index d4ddb13693..769bcb6e54 100644
--- a/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/solution.md
+++ b/5-regular-expressions/07-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) ); // ..., .....
 ```
 
-Please note that the dot is a special character, so we have to escape it and insert as `\.`.
+需要注意的是，点号（.）是一个特殊字符，因此我们需要将其转义并作为 `\.` 插入语句。

From df9e534420e55453c88b790067467c4fd98b7159 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E6=B1=89=E7=A5=A5?= <l945457758@gmail.com>
Date: Wed, 12 Sep 2018 18:25:49 +0800
Subject: [PATCH 02/16] task.md

---
 .../07-regexp-quantifiers/1-find-text-manydots/task.md      | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md b/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md
index 6fd91bdcf3..73a7d1c831 100644
--- a/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md
+++ b/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-#  How to find an ellipsis "..." ?
+#  如何找到省略号 "..." ？
 
-Create a regexp to find ellipsis: 3 (or more?) dots in a row.
+创建一个正则表达式来查找省略号：连续 3（或更多）个点。
 
-Check it:
+来一探究竟：
 
 ```js
 let reg = /your regexp/g;

From b4890a230a5b11fad9a79ff5aebff4d54a3152ea Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E6=B1=89=E7=A5=A5?= <l945457758@gmail.com>
Date: Wed, 12 Sep 2018 18:32:12 +0800
Subject: [PATCH 03/16] task.md

---
 .../2-find-html-colors-6hex/task.md                    | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/task.md b/5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/task.md
index 1960a09c61..e7d78a7f70 100644
--- a/5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/task.md
+++ b/5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/task.md
@@ -1,15 +1,15 @@
-# Regexp for HTML colors
+# 针对 HTML 颜色的正则表达式
 
-Create a regexp to search HTML-colors written as `#ABCDEF`: first `#` and then 6 hexadimal characters.
+创建一个正则表达式来搜寻格式为 `#ABCDEF` 的 HTML 颜色值： 首个字符 `#` 以及接下来的六位十六进制字符。
 
-An example of use:
+一个例子：
 
 ```js
-let reg = /...your regexp.../
+let reg = /...你的正则表达式.../
 
 let str = "color:#121212; background-color:#AA00ef bad-colors:f#fddee #fd2 #12345678";
 
 alert( str.match(reg) )  // #121212,#AA00ef
 ```
 
-P.S. In this task we do not need other color formats like `#123` or `rgb(1,2,3)` etc.
+P.S. 在这个任务中，我们不需要其他的颜色格式，比如 `#123` 或 `rgb(1,2,3)` 等。

From 859c384a29cf51d920336260dfe7c17665d92e98 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E6=B1=89=E7=A5=A5?= <l945457758@gmail.com>
Date: Wed, 12 Sep 2018 18:33:24 +0800
Subject: [PATCH 04/16] task.md

---
 .../07-regexp-quantifiers/1-find-text-manydots/task.md          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md b/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md
index 73a7d1c831..279eee307f 100644
--- a/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md
+++ b/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md
@@ -9,6 +9,6 @@ importance: 5
 来一探究竟：
 
 ```js
-let reg = /your regexp/g;
+let reg = /你的正则表达式/g;
 alert( "Hello!... How goes?.....".match(reg) ); // ..., .....
 ```

From 49e66ee4c19ad09da1cac2add9e54a808834e3da Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E6=B1=89=E7=A5=A5?= <l945457758@gmail.com>
Date: Wed, 12 Sep 2018 19:02:24 +0800
Subject: [PATCH 05/16] solution.md

---
 .../2-find-html-colors-6hex/solution.md              | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/solution.md b/5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/solution.md
index ec871d05c3..87d5934ec8 100644
--- a/5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/solution.md
+++ b/5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/solution.md
@@ -1,10 +1,10 @@
-We need to look for `#` followed by 6 hexadimal characters.
+我们需要寻找 `#` 字符，后跟六个十六进制字符。
 
-A hexadimal character can be described as `pattern:[0-9a-fA-F]`. Or if we use the `i` flag, then just  `pattern:[0-9a-f]`.
+一个十六进制字符可以被描述为 `pattern:[0-9a-fA-F]`。如果我们使用 `i` 标识，那么只需要 `pattern:[0-9a-f]`。
 
-Then we can look for 6 of them using the quantifier `pattern:{6}`.
+然后我们可以用量词 `pattern:{6}` 来查找这六个。
 
-As a result, we have the regexp: `pattern:/#[a-f0-9]{6}/gi`.
+因此，我们得到正则表达式：`pattern:/#[a-f0-9]{6}/gi`。
 
 ```js run
 let reg = /#[a-f0-9]{6}/gi;
@@ -14,13 +14,13 @@ let str = "color:#121212; background-color:#AA00ef bad-colors:f#fddee #fd2"
 alert( str.match(reg) );  // #121212,#AA00ef
 ```
 
-The problem is that it finds the color in longer sequences:
+问题是它找到了更长序列的颜色值：
 
 ```js run
 alert( "#12345678".match( /#[a-f0-9]{6}/gi ) ) // #12345678
 ```
 
-To fix that, we can add `pattern:\b` to the end:
+为了解决这个问题，我们可以在末尾加上 `pattern:\b`：
 
 ```js run
 // color

From f9b4e5cb1fadf9cded85481fdf4e4263d24676c7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E6=B1=89=E7=A5=A5?= <l945457758@gmail.com>
Date: Wed, 12 Sep 2018 20:41:40 +0800
Subject: [PATCH 06/16] =?UTF-8?q?=E9=87=8F=E8=AF=8D=20+,*,=3F=20=E5=92=8C?=
 =?UTF-8?q?=20{n}?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../07-regexp-quantifiers/article.md          | 78 +++++++++----------
 1 file changed, 38 insertions(+), 40 deletions(-)

diff --git a/5-regular-expressions/07-regexp-quantifiers/article.md b/5-regular-expressions/07-regexp-quantifiers/article.md
index 6b6933bb4a..7513ddf0d8 100644
--- a/5-regular-expressions/07-regexp-quantifiers/article.md
+++ b/5-regular-expressions/07-regexp-quantifiers/article.md
@@ -1,40 +1,40 @@
-# Quantifiers +, *, ? and {n}
+# 量词 +,*,? 和 {n}
 
-Let's say we have a string like `+7(903)-123-45-67` and want to find all numbers in it. But unlike before, we are interested in not digits, but full numbers: `7, 903, 123, 45, 67`.
+假设我们有一个字符串 `+7(903)-123-45-67`，并且想要找到它包含的所有数字。但与之前不同的是，我们对单个数字不感兴趣，只对全数感兴趣：`7, 903, 123, 45, 67`。
 
-A number is a sequence of 1 or more digits `\d`. The instrument to say how many we need is called *quantifiers*.
+数字是一个或多个 `\d` 的序列。用来形容我们所需要的数量的词被称为**量词**。
 
-## Quantity {n}
+## 数量 {n}
 
-The most obvious quantifier is a number in figure quotes: `pattern:{n}`. A quantifier is put after a character (or a character class and so on) and specifies exactly how many we need.
+最明显的量词便是一对引号间的数字：`pattern:{n}`。在一个字符（或一个字符类等等）后跟着一个量词，用来指出我们具体需要的数量。
 
-It also has advanced forms, here we go with examples:
+它有更高级的格式，用一个例子来说明：
 
-Exact count: `{5}`
-: `pattern:\d{5}` denotes exactly 5 digits, the same as `pattern:\d\d\d\d\d`.
+确切的位数：`{5}`
+：`pattern:\d{5}` 表示 5 位的数字，如同 `pattern:\d\d\d\d\d`。
 
-    The example below looks for a 5-digit number:
+    接下来的例子将会查找一个五位数的数字
 
     ```js run
     alert( "I'm 12345 years old".match(/\d{5}/) ); //  "12345"
     ```
 
-    We can add `\b` to exclude longer numbers: `pattern:\b\d{5}\b`.
+    我们可以添加 `\b` 来排除更多位数的数字：`pattern:\b\d{5}\b`。
 
-The count from-to: `{3,5}`
-: To find numbers from 3 to 5 digits we can put the limits into figure brackets: `pattern:\d{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"
     ```
 
-    We can omit the upper limit. Then a regexp `pattern:\d{3,}` looks for numbers of `3` and more digits:
+    我们可以省略上限。那么正则表达式 `pattern:\d{3,}` 就会查找位数大于或等于 3 的数字：
 
     ```js run
     alert( "I'm not 12, but 345678 years old".match(/\d{3,}/) ); // "345678"
     ```
 
-In case with the string `+7(903)-123-45-67` we need numbers: one or more digits in a row. That is  `pattern:\d{1,}`:
+对于字符串 `+7(903)-123-45-67` 来说，我们如果需要一个或多个连续的数字，就使用 `pattern:\d{1,}`：
 
 ```js run
 let str = "+7(903)-123-45-67";
@@ -44,14 +44,14 @@ let numbers = str.match(/\d{1,}/g);
 alert(numbers); // 7,903,123,45,67
 ```
 
-## Shorthands
+## 缩写
 
-Most often needed quantifiers have shorthands:
+大多数常用的量词都可以有缩写：
 
 `+`
-: Means "one or more", the same as `{1,}`.
+：代表“一个或多个”，相当于 `{1,}`。
 
-    For instance, `pattern:\d+` looks for numbers:
+    例如，`pattern:\d+` 用来查找所有数字：
 
     ```js run
     let str = "+7(903)-123-45-67";
@@ -60,11 +60,11 @@ Most often needed quantifiers have shorthands:
     ```
 
 `?`
-: Means "zero or one", the same as `{0,1}`. In other words, it makes the symbol optional.
+：代表“零个或一个”，相当于 `{0,1}`。换句话说，它使得符号变得可选。
 
-    For instance, the pattern `pattern:ou?r` looks for `match:o` followed by zero or one `match:u`, and then `match:r`.
+    例如，模式 `pattern:ou?r` 查找 `match:o`，后跟零个或一个 `match:u`，然后是 `match:r`。
 
-    So it can find `match:or` in the word `subject:color` and `match:our` in `subject:colour`:
+    所以他能够在 `subject:color` 中找到 `match:or`，以及在 `subject:colour` 中找到 `match:our`：
 
     ```js run
     let str = "Should I write color or colour?";
@@ -73,61 +73,59 @@ Most often needed quantifiers have shorthands:
     ```
 
 `*`
-: Means "zero or more", the same as `{0,}`. That is, the character may repeat any times or be absent.
+：代表着“零个或多个”，相当于 `{0,}`。也就是说，这个字符可以多次出现或不出现。
 
-    The example below looks for a digit followed by any number of zeroes:
+    接下来的例子将要寻找一个后跟任意数量的 0 的数字：
 
     ```js run
     alert( "100 10 1".match(/\d0*/g) ); // 100, 10, 1
     ```
 
-    Compare it with `'+'` (one or more):
+    将它与 `'+'` (一个或多个)作比较：
 
     ```js run
     alert( "100 10 1".match(/\d0+/g) ); // 100, 10
     ```
 
-## More examples
+## 更多示例
 
-Quantifiers are used very often. They are one of the main "building blocks" for complex regular expressions, so let's see more examples.
+量词是经常被使用的。它们是构成复杂的正则表达式的主要模块之一，我们接着来看更多的例子。
 
-Regexp "decimal fraction" (a number with a floating point): `pattern:\d+\.\d+`
-: In action:
+正则表达式“浮点数”（带浮点的数字）：`pattern:\d+\.\d+`
+：实现：
     ```js run
     alert( "0 1 12.345 7890".match(/\d+\.\d+/g) ); // 12.345
     ```
 
-Regexp "open HTML-tag without attributes", like `<span>` or `<p>`: `pattern:/<[a-z]+>/i`
-: In action:
+正则表达式“打开没有属性的HTML标记”，比如 `<span>` 或 `<p>`：`pattern:/<[a-z]+>/i`
+：实现：
 
     ```js run
     alert( "<body> ... </body>".match(/<[a-z]+>/gi) ); // <body>
     ```
 
-    We look for character `pattern:'<'` followed by one or more English letters, and then  `pattern:'>'`.
+    我们查找字符 `pattern:'<'` 后跟一个或多个英文字母，然后是 `pattern:'>'`。
 
-Regexp "open HTML-tag without attributes" (improved): `pattern:/<[a-z][a-z0-9]*>/i`
-: Better regexp: according to the standard, HTML tag name may have a digit at any position except the first one, like `<h1>`.
+正则表达式“打开没有属性的HTML标记”（改进版）：`pattern:/<[a-z][a-z0-9]*>/i`：更好的表达式：根据标准，HTML 标记名称可以在除了第一个位置以外的任意一个位置有一个数字，比如 `<h1>`。
 
     ```js run
     alert( "<h1>Hi!</h1>".match(/<[a-z][a-z0-9]*>/gi) ); // <h1>
     ```
 
-Regexp "opening or closing HTML-tag without attributes": `pattern:/<\/?[a-z][a-z0-9]*>/i`
-: We added an optional slash `pattern:/?` before the tag. Had to escape it with a backslash, otherwise JavaScript would think it is the pattern end.
+正则表达式“打开没有属性的HTML标记”：`pattern:/<\/?[a-z][a-z0-9]*>/i`：我们在标记前加上了一个可选的斜杆 `pattern:/?`。必须用一个反斜杠来转义它，否则 JavaScript 就会认为它是这个模式的结束符。
 
     ```js run
     alert( "<h1>Hi!</h1>".match(/<\/?[a-z][a-z0-9]*>/gi) ); // <h1>, </h1>
     ```
 
 ```smart header="More precise means more complex"
-We can see one common rule in these examples: the more precise is the regular expression -- the longer and more complex it is.
+我们能够从这些例子中看到一个共同的规则：正则表达式越精确 —— 它就越长且越复杂。
 
-For instance, HTML tags could use a simpler regexp: `pattern:<\w+>`.
+例如，HTML 标记能用一个简单的正则表达式：`pattern:<\w+>`。
 
-Because `pattern:\w` means any English letter or a digit or `'_'`, the regexp also matches non-tags, for instance `match:<_>`. But it's much simpler than `pattern:<[a-z][a-z0-9]*>`.
+因为 `pattern:\w` 代表任意英文字母或数字或`'_'`，这个正则表达式也能够匹配非标注的内容，比如 `match:<_>`。但它要比 `pattern:<[a-z][a-z0-9]*>` 简单很多。
 
-Are we ok with `pattern:<\w+>` or we need `pattern:<[a-z][a-z0-9]*>`?
+我们能够接受 `pattern:<\w+>` 或者我们需要 `pattern:<[a-z][a-z0-9]*>`？
 
-In real life both variants are acceptable. Depends on how tolerant we can be to "extra" matches and whether it's difficult or not to filter them out by other means.
+在现实生活中，两种方式都能接受。取决于我们对于“额外”匹配的宽容程度以及是否难以通过其他方式来过滤掉它们。
 ```

From f3861986979a0d5955ea6167abb413a5d8309230 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E6=B1=89=E7=A5=A5?= <l945457758@gmail.com>
Date: Wed, 12 Sep 2018 20:48:20 +0800
Subject: [PATCH 07/16] =?UTF-8?q?#=20=E9=87=8F=E8=AF=8D=20+,*,=3F=20?=
 =?UTF-8?q?=E5=92=8C=20{n}?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 5-regular-expressions/07-regexp-quantifiers/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/5-regular-expressions/07-regexp-quantifiers/article.md b/5-regular-expressions/07-regexp-quantifiers/article.md
index 7513ddf0d8..36a39c4cd6 100644
--- a/5-regular-expressions/07-regexp-quantifiers/article.md
+++ b/5-regular-expressions/07-regexp-quantifiers/article.md
@@ -118,7 +118,7 @@ alert(numbers); // 7,903,123,45,67
     alert( "<h1>Hi!</h1>".match(/<\/?[a-z][a-z0-9]*>/gi) ); // <h1>, </h1>
     ```
 
-```smart header="More precise means more complex"
+```smart header=“更精确意味着更复杂”
 我们能够从这些例子中看到一个共同的规则：正则表达式越精确 —— 它就越长且越复杂。
 
 例如，HTML 标记能用一个简单的正则表达式：`pattern:<\w+>`。

From d6e0983972a7ede2ee3d9758d55380fd2376fa5a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E6=B1=89=E7=A5=A5?= <l945457758@gmail.com>
Date: Mon, 17 Sep 2018 13:51:19 +0800
Subject: [PATCH 08/16] =?UTF-8?q?=E6=A0=B9=E6=8D=AE=E6=A0=A1=E5=AF=B9?=
 =?UTF-8?q?=E6=84=8F=E8=A7=81=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../07-regexp-quantifiers/1-find-text-manydots/task.md          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md b/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md
index 279eee307f..e969bed9ae 100644
--- a/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md
+++ b/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md
@@ -6,7 +6,7 @@ importance: 5
 
 创建一个正则表达式来查找省略号：连续 3（或更多）个点。
 
-来一探究竟：
+例如：
 
 ```js
 let reg = /你的正则表达式/g;

From 548d3b5215a1fd12bce170cb25d2fd23db1126b0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E6=B1=89=E7=A5=A5?= <l945457758@gmail.com>
Date: Mon, 17 Sep 2018 13:52:07 +0800
Subject: [PATCH 09/16] =?UTF-8?q?=E6=A0=B9=E6=8D=AE=E6=A0=A1=E5=AF=B9?=
 =?UTF-8?q?=E6=84=8F=E8=A7=81=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../07-regexp-quantifiers/2-find-html-colors-6hex/solution.md   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/solution.md b/5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/solution.md
index 87d5934ec8..2f206df3f8 100644
--- a/5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/solution.md
+++ b/5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/solution.md
@@ -14,7 +14,7 @@ let str = "color:#121212; background-color:#AA00ef bad-colors:f#fddee #fd2"
 alert( str.match(reg) );  // #121212,#AA00ef
 ```
 
-问题是它找到了更长序列的颜色值：
+问题是匹配到颜色值过长：
 
 ```js run
 alert( "#12345678".match( /#[a-f0-9]{6}/gi ) ) // #12345678

From 514d350452d360ad6c2beb1c021f8bf83b4a2837 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E6=B1=89=E7=A5=A5?= <l945457758@gmail.com>
Date: Mon, 17 Sep 2018 13:52:44 +0800
Subject: [PATCH 10/16] =?UTF-8?q?=E6=A0=B9=E6=8D=AE=E6=A0=A1=E5=AF=B9?=
 =?UTF-8?q?=E6=84=8F=E8=A7=81=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 5-regular-expressions/07-regexp-quantifiers/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/5-regular-expressions/07-regexp-quantifiers/article.md b/5-regular-expressions/07-regexp-quantifiers/article.md
index 36a39c4cd6..2a2bd8d424 100644
--- a/5-regular-expressions/07-regexp-quantifiers/article.md
+++ b/5-regular-expressions/07-regexp-quantifiers/article.md
@@ -13,7 +13,7 @@
 确切的位数：`{5}`
 ：`pattern:\d{5}` 表示 5 位的数字，如同 `pattern:\d\d\d\d\d`。
 
-    接下来的例子将会查找一个五位数的数字
+    接下来的例子将会查找一个五位数的数字：
 
     ```js run
     alert( "I'm 12345 years old".match(/\d{5}/) ); //  "12345"

From cd28ec3968432771057046b79d2c4412a64e5de2 Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Mon, 17 Sep 2018 21:37:35 +0800
Subject: [PATCH 11/16] Update solution.md

---
 .../07-regexp-quantifiers/1-find-text-manydots/solution.md     | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/solution.md b/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/solution.md
index 769bcb6e54..4c96c58fd7 100644
--- a/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/solution.md
+++ b/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/solution.md
@@ -1,5 +1,4 @@
-
-解答:
+solution:
 
 ```js run
 let reg = /\.{3,}/g;

From ab0daab4e7d3aeceb092d1bcf066b95289d236cd Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Mon, 17 Sep 2018 21:37:51 +0800
Subject: [PATCH 12/16] Update solution.md

---
 .../07-regexp-quantifiers/1-find-text-manydots/solution.md     | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/solution.md b/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/solution.md
index 4c96c58fd7..0aabba0dee 100644
--- a/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/solution.md
+++ b/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/solution.md
@@ -1,4 +1,5 @@
-solution:
+
+Solution:
 
 ```js run
 let reg = /\.{3,}/g;

From c742f4b9d192eaa34c32042e3296fc5e2b4b4ea6 Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Mon, 17 Sep 2018 21:38:33 +0800
Subject: [PATCH 13/16] Update task.md

---
 .../07-regexp-quantifiers/1-find-text-manydots/task.md          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md b/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md
index e969bed9ae..33c516a6ce 100644
--- a/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md
+++ b/5-regular-expressions/07-regexp-quantifiers/1-find-text-manydots/task.md
@@ -2,7 +2,7 @@ importance: 5
 
 ---
 
-#  如何找到省略号 "..." ？
+#  如何找到省略号 "..."？
 
 创建一个正则表达式来查找省略号：连续 3（或更多）个点。
 

From 110d15ae2a40c4c9823807275c30fa6fe2568328 Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Mon, 17 Sep 2018 21:39:23 +0800
Subject: [PATCH 14/16] Update task.md

---
 .../07-regexp-quantifiers/2-find-html-colors-6hex/task.md       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/task.md b/5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/task.md
index e7d78a7f70..19b0046284 100644
--- a/5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/task.md
+++ b/5-regular-expressions/07-regexp-quantifiers/2-find-html-colors-6hex/task.md
@@ -1,6 +1,6 @@
 # 针对 HTML 颜色的正则表达式
 
-创建一个正则表达式来搜寻格式为 `#ABCDEF` 的 HTML 颜色值： 首个字符 `#` 以及接下来的六位十六进制字符。
+创建一个正则表达式来搜寻格式为 `#ABCDEF` 的 HTML 颜色值：首个字符 `#` 以及接下来的六位十六进制字符。
 
 一个例子：
 

From bea1342cce9575e51067055014130ab19b12d940 Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Mon, 17 Sep 2018 21:40:11 +0800
Subject: [PATCH 15/16] Update article.md

---
 5-regular-expressions/07-regexp-quantifiers/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/5-regular-expressions/07-regexp-quantifiers/article.md b/5-regular-expressions/07-regexp-quantifiers/article.md
index 2a2bd8d424..87ef7f8510 100644
--- a/5-regular-expressions/07-regexp-quantifiers/article.md
+++ b/5-regular-expressions/07-regexp-quantifiers/article.md
@@ -1,4 +1,4 @@
-# 量词 +,*,? 和 {n}
+# 量词 `+,*,?` 和 `{n}`
 
 假设我们有一个字符串 `+7(903)-123-45-67`，并且想要找到它包含的所有数字。但与之前不同的是，我们对单个数字不感兴趣，只对全数感兴趣：`7, 903, 123, 45, 67`。
 

From c002e67ec057f1fa0de667f4539c4c4023f8da7c Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Mon, 17 Sep 2018 21:46:02 +0800
Subject: [PATCH 16/16] Update article.md

---
 .../07-regexp-quantifiers/article.md          | 26 ++++++++++---------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/5-regular-expressions/07-regexp-quantifiers/article.md b/5-regular-expressions/07-regexp-quantifiers/article.md
index 87ef7f8510..a5583869af 100644
--- a/5-regular-expressions/07-regexp-quantifiers/article.md
+++ b/5-regular-expressions/07-regexp-quantifiers/article.md
@@ -11,7 +11,7 @@
 它有更高级的格式，用一个例子来说明：
 
 确切的位数：`{5}`
-：`pattern:\d{5}` 表示 5 位的数字，如同 `pattern:\d\d\d\d\d`。
+: `pattern:\d{5}` 表示 5 位的数字，如同 `pattern:\d\d\d\d\d`。
 
     接下来的例子将会查找一个五位数的数字：
 
@@ -22,7 +22,7 @@
     我们可以添加 `\b` 来排除更多位数的数字：`pattern:\b\d{5}\b`。
 
 某个范围的位数：`{3,5}`
-：我们可以将限制范围的数字放入括号中，来查找位数为 3 至 5 位的数字：`pattern:\d{3,5}`
+: 我们可以将限制范围的数字放入括号中，来查找位数为 3 至 5 位的数字：`pattern:\d{3,5}`
 
     ```js run
     alert( "I'm not 12, but 1234 years old".match(/\d{3,5}/) ); // "1234"
@@ -49,7 +49,7 @@ alert(numbers); // 7,903,123,45,67
 大多数常用的量词都可以有缩写：
 
 `+`
-：代表“一个或多个”，相当于 `{1,}`。
+: 代表“一个或多个”，相当于 `{1,}`。
 
     例如，`pattern:\d+` 用来查找所有数字：
 
@@ -60,7 +60,7 @@ alert(numbers); // 7,903,123,45,67
     ```
 
 `?`
-：代表“零个或一个”，相当于 `{0,1}`。换句话说，它使得符号变得可选。
+: 代表“零个或一个”，相当于 `{0,1}`。换句话说，它使得符号变得可选。
 
     例如，模式 `pattern:ou?r` 查找 `match:o`，后跟零个或一个 `match:u`，然后是 `match:r`。
 
@@ -81,7 +81,7 @@ alert(numbers); // 7,903,123,45,67
     alert( "100 10 1".match(/\d0*/g) ); // 100, 10, 1
     ```
 
-    将它与 `'+'` (一个或多个)作比较：
+    将它与 `'+'`（一个或多个）作比较：
 
     ```js run
     alert( "100 10 1".match(/\d0+/g) ); // 100, 10
@@ -92,13 +92,13 @@ alert(numbers); // 7,903,123,45,67
 量词是经常被使用的。它们是构成复杂的正则表达式的主要模块之一，我们接着来看更多的例子。
 
 正则表达式“浮点数”（带浮点的数字）：`pattern:\d+\.\d+`
-：实现：
+: 实现：
     ```js run
     alert( "0 1 12.345 7890".match(/\d+\.\d+/g) ); // 12.345
     ```
 
-正则表达式“打开没有属性的HTML标记”，比如 `<span>` 或 `<p>`：`pattern:/<[a-z]+>/i`
-：实现：
+正则表达式“打开没有属性的 HTML 标记”，比如 `<span>` 或 `<p>`：`pattern:/<[a-z]+>/i`
+: 实现：
 
     ```js run
     alert( "<body> ... </body>".match(/<[a-z]+>/gi) ); // <body>
@@ -106,24 +106,26 @@ alert(numbers); // 7,903,123,45,67
 
     我们查找字符 `pattern:'<'` 后跟一个或多个英文字母，然后是 `pattern:'>'`。
 
-正则表达式“打开没有属性的HTML标记”（改进版）：`pattern:/<[a-z][a-z0-9]*>/i`：更好的表达式：根据标准，HTML 标记名称可以在除了第一个位置以外的任意一个位置有一个数字，比如 `<h1>`。
+正则表达式“打开没有属性的HTML标记”（改进版）：`pattern:/<[a-z][a-z0-9]*>/i`
+: 更好的表达式：根据标准，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`
+: 我们在标记前加上了一个可选的斜杆 `pattern:/?`。必须用一个反斜杠来转义它，否则 JavaScript 就会认为它是这个模式的结束符。
 
     ```js run
     alert( "<h1>Hi!</h1>".match(/<\/?[a-z][a-z0-9]*>/gi) ); // <h1>, </h1>
     ```
 
-```smart header=“更精确意味着更复杂”
+```smart header="更精确意味着更复杂"
 我们能够从这些例子中看到一个共同的规则：正则表达式越精确 —— 它就越长且越复杂。
 
 例如，HTML 标记能用一个简单的正则表达式：`pattern:<\w+>`。
 
-因为 `pattern:\w` 代表任意英文字母或数字或`'_'`，这个正则表达式也能够匹配非标注的内容，比如 `match:<_>`。但它要比 `pattern:<[a-z][a-z0-9]*>` 简单很多。
+因为 `pattern:\w` 代表任意英文字母或数字或 `'_'`，这个正则表达式也能够匹配非标注的内容，比如 `match:<_>`。但它要比 `pattern:<[a-z][a-z0-9]*>` 简单很多。
 
 我们能够接受 `pattern:<\w+>` 或者我们需要 `pattern:<[a-z][a-z0-9]*>`？