diff --git a/docs/regex.md b/docs/regex.md
index e027a36..6644e83 100644
--- a/docs/regex.md
+++ b/docs/regex.md
@@ -5,7 +5,7 @@
 在ES5中，RegExp构造函数只能接受字符串作为参数。
 
 ```javascript
-var regex = new RegExp("xyz", "i");
+var regex = new RegExp('xyz', 'i');
 // 等价于
 var regex = /xyz/i;
 ```
@@ -54,7 +54,7 @@ ES6对正则表达式添加了`u`修饰符，含义为“Unicode模式”，用
 点（.）字符在正则表达式中，含义是除了换行符以外的任意单个字符。对于码点大于`0xFFFF`的Unicode字符，点字符不能识别，必须加上u修饰符。
 
 ```javascript
-var s = "𠮷";
+var s = '𠮷';
 
 /^.$/.test(s) // false
 /^.$/u.test(s) // true
@@ -112,7 +112,7 @@ function codePointLength(text) {
   return result ? result.length : 0;
 }
 
-var s = "𠮷𠮷";
+var s = '𠮷𠮷';
 
 s.length // 4
 codePointLength(s) // 2
@@ -136,7 +136,7 @@ codePointLength(s) // 2
 y修饰符的作用与g修饰符类似，也是全局匹配，后一次匹配都从上一次匹配成功的下一个位置开始。不同之处在于，g修饰符只要剩余位置中存在匹配就可，而y修饰符确保匹配必须从剩余的第一个位置开始，这也就是“粘连”的涵义。
 
 ```javascript
-var s = "aaa_aa_a";
+var s = 'aaa_aa_a';
 var r1 = /a+/g;
 var r2 = /a+/y;
 
@@ -207,7 +207,7 @@ REGEX.lastIndex // 4
 进一步说，`y`修饰符号隐含了头部匹配的标志ˆ。
 
 ```javascript
-/b/y.exec("aba")
+/b/y.exec('aba')
 // null
 ```
 
@@ -307,7 +307,7 @@ ES6为正则表达式新增了flags属性，会返回正则表达式的修饰符
 
 ```javascript
 function escapeRegExp(str) {
-  return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+  return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
 }
 
 let str = '/path/to/resource.html?search=query';
@@ -320,13 +320,13 @@ escapeRegExp(str)
 已经有[提议](https://esdiscuss.org/topic/regexp-escape)将这个需求标准化，作为RegExp对象的静态方法[RegExp.escape()](https://github.com/benjamingr/RexExp.escape)，放入ES7。2015年7月31日，TC39认为，这个方法有安全风险，又不愿这个方法变得过于复杂，没有同意将其列入ES7，但这不失为一个真实的需求。
 
 ```javascript
-RegExp.escape("The Quick Brown Fox");
+RegExp.escape('The Quick Brown Fox');
 // "The Quick Brown Fox"
 
-RegExp.escape("Buy it. use it. break it. fix it.")
+RegExp.escape('Buy it. use it. break it. fix it.');
 // "Buy it\. use it\. break it\. fix it\."
 
-RegExp.escape("(*.*)");
+RegExp.escape('(*.*)');
 // "\(\*\.\*\)"
 ```
 
@@ -342,8 +342,8 @@ assert.equal(String(regex), '/hello\. how are you\?/g');
 
 ```javascript
 var escape = require('regexp.escape');
-escape('hi. how are you?')
-"hi\\. how are you\\?"
+escape('hi. how are you?');
+// "hi\\. how are you\\?"
 ```
 
 ## 后行断言
@@ -355,22 +355,22 @@ JavaScript语言的正则表达式，只支持先行断言（lookahead）和先
 ”先行断言“指的是，`x`只有在`y`前面才匹配，必须写成`/x(?=y)/`。比如，只匹配百分号之前的数字，要写成`/\d+(?=%)/`。”先行否定断言“指的是，`x`只有不在`y`前面才匹配，必须写成`/x(?!y)/`。比如，只匹配不在百分号之前的数字，要写成`/\d+(?!%)/`。
 
 ```javascript
-/\d+(?=%)/.exec("100% of US presidents have been male")  // ["100"]
-/\d+(?!%)/.exec("that’s all 44 of them")                 // ["44"]
+/\d+(?=%)/.exec('100% of US presidents have been male')  // ["100"]
+/\d+(?!%)/.exec('that’s all 44 of them')                 // ["44"]
 ```
 
 上面两个字符串，如果互换正则表达式，就会匹配失败。另外，还可以看到，”先行断言“括号之中的部分（`(?=%)`），是不计入返回结果的。
 
-”后行断言“正好与”先行断言“相反，`x`只有在`y`后面才匹配，必须写成`/(?<=y)x/`。比如，只匹配美元符号之后的数字，要写成`/(?<=\$)\d+/`。”后行否定断言“则与”先行否定断言“相反，`x`只有不在`y`后面才匹配，必须写成`/(?<!y)x/`。比如，只匹配不在美元符号后面的数字，要写成`/(?<!\$)\d+/`。
+"后行断言"正好与"先行断言"相反，`x`只有在`y`后面才匹配，必须写成`/(?<=y)x/`。比如，只匹配美元符号之后的数字，要写成`/(?<=\$)\d+/`。”后行否定断言“则与”先行否定断言“相反，`x`只有不在`y`后面才匹配，必须写成`/(?<!y)x/`。比如，只匹配不在美元符号后面的数字，要写成`/(?<!\$)\d+/`。
 
 ```javascript
-/(?<=\$)\d+/.exec("Benjamin Franklin is on the $100 bill")  // ["100"]
-/(?<!\$)\d+/.exec("it’s is worth about €90")                // ["90"]
+/(?<=\$)\d+/.exec('Benjamin Franklin is on the $100 bill')  // ["100"]
+/(?<!\$)\d+/.exec('it’s is worth about €90')                // ["90"]
 ```
 
-上面的例子中，”后行断言“的括号之中的部分（`(?<=\$)`），也是不计入返回结果。
+上面的例子中，"后行断言"的括号之中的部分（`(?<=\$)`），也是不计入返回结果。
 
-”后行断言“的实现，需要先匹配`/(?<=y)x/`的`x`，然后再回到左边，匹配`y`的部分。这种”先右后左“的执行顺序，与所有其他正则操作相反，导致了一些不符合预期的行为。
+"后行断言"的实现，需要先匹配`/(?<=y)x/`的`x`，然后再回到左边，匹配`y`的部分。这种"先右后左"的执行顺序，与所有其他正则操作相反，导致了一些不符合预期的行为。
 
 首先，”后行断言“的组匹配，与正常情况下结果是不一样的。
 
@@ -379,13 +379,13 @@ JavaScript语言的正则表达式，只支持先行断言（lookahead）和先
 /^(\d+)(\d+)$/.exec('1053') // ["1053", "105", "3"]
 ```
 
-上面代码中，需要捕捉两个组匹配。没有”后行断言“时，第一个括号是贪婪模式，第二个括号只能捕获一个字符，所以结果是`105`和`3`。而”后行断言“时，由于执行顺序是从右到左，第二个括号是贪婪模式，第一个括号只能捕获一个字符，所以结果是`1`和`053`。
+上面代码中，需要捕捉两个组匹配。没有"后行断言"时，第一个括号是贪婪模式，第二个括号只能捕获一个字符，所以结果是`105`和`3`。而"后行断言"时，由于执行顺序是从右到左，第二个括号是贪婪模式，第一个括号只能捕获一个字符，所以结果是`1`和`053`。
 
-其次，”后行断言“的反斜杠引用，也与通常的顺序相反，必须放在对应的那个括号之前。
+其次，"后行断言"的反斜杠引用，也与通常的顺序相反，必须放在对应的那个括号之前。
 
 ```javascript
-/(?<=(o)d\1)r/.exec("hodor")  // null
-/(?<=\1d(o))r/.exec("hodor")  // ["r", "o"]
+/(?<=(o)d\1)r/.exec('hodor')  // null
+/(?<=\1d(o))r/.exec('hodor')  // ["r", "o"]
 ```
 
 上面代码中，如果后行断言的反斜杠引用（`\1`）放在括号的后面，就不会得到匹配结果，必须放在前面才可以。