conflicts

Author: yibuyisheng

README.md

@@ -8,7 +8,7 @@
 
 阮老师的那本书确实不错，值得 ES6 初学者去阅读。但是阮老师对这本书的定位是“中级难度”，也就是说书中不会很深入地去剖析各个知识点，而《 Exploring ES6 》这本书就努力在向大家细致地深入地讲解 ES6 的方方面面，这也是我觉得这本书很不错的原因。
 
-此外，《 Exploring ES6 》的作者对 JavaScript 有比较少深入全面的了解，也出了一本 ES5 及之前版本的书[《 Speaking JavaScript: An In-Depth Guide for Programmers 》](http://speakingjs.com/)。
+此外，《 Exploring ES6 》的作者对 JavaScript 有比较深入全面的了解，也出了一本 ES5 及之前版本的书[《 Speaking JavaScript: An In-Depth Guide for Programmers 》](http://speakingjs.com/)。
 
 所以，总的来说，《 Exploring ES6 》还是值得一看的。
 

md/6.2.md

@@ -0,0 +1,10 @@
+## 6.2 Unicode 码点解析
+
+在 ECMAScript 6 中，存在一种新的 Unicode 码点解析方式：能够指定任何编码方式（即便这种编码方式超过了16位）：
+
+```js
+console.log('\u{1F680}'); // ES6: 一个码点
+console.log('\uD83D\uDE80'); // ES5: 两个码点单元
+```
+
+本章关于 Unicode 的部分展示了更多信息。

md/6.1.md md/6/6.1.mdmd/6.1.md renamed to md/6/6.1.md

@@ -0,0 +1,29 @@
+## 6.3 字符串插值，多行字符串字面量和原始字符串字面量
+
+模板字面量有专门的章节深入讲述，其提供了三种有意思的特性。
+
+首先，模板字面量支持字符串插值：
+
+```js
+const first = 'Jane';
+const last = 'Doe';
+console.log(`Hello ${first} ${last}!`);
+ // Hello Jane Doe!
+```
+
+其次，模板字面量可以跨多行：
+
+```js
+const multiLine = `
+This is
+a string
+with multiple
+lines`;
+```
+
+最后，如果在模板字面量前面加上*标签* `String.raw` ，那么就变成了“原生的”的字符串了，反斜杠再也不是用于转义的特殊字符，也就是说， `\n` 不会转义成换行符：
+
+```js
+const str = String.raw`Not a newline: \n`;
+console.log(str === 'Not a newline: \\n'); // true
+```

md/6/6.2.md

@@ -0,0 +1,66 @@
+## 6.4 字符串遍历
+
+字符串是可遍历的，也就是说可以使用 `for-of` 遍历字符串中的字符：
+
+```js
+for (const ch of 'abc') {
+ console.log(ch);
+}
+// Output:
+// a
+// b
+// c
+```
+
+也可以使用扩展操作符（...）将字符串转换成数组：
+
+```js
+const chars = [...'abc'];
+ // ['a', 'b', 'c']
+```
+
+### 6.4.1 字符串遍历遵循 Unicode 码点规则
+
+字符串遍历的时候，分割字符串是按照码点边界来的，这意味着遍历的时候拿到的字符可能由一个或者两个 JavaScript 字符组成：
+
+```js
+for (const ch of 'x\uD83D\uDE80y') {
+ console.log(ch.length);
+}
+// Output:
+// 1
+// 2
+// 1
+```
+
+### 6.4.2 计算码点数
+
+遍历是一种快速计算字符串 Unicode 码点数的方式：
+
+```
+> [...'x\uD83D\uDE80y'].length
+3
+```
+
+### 6.4.3 翻转包含非 BMP 码点的字符串
+
+利用遍历也能够实现翻转包含非 BMP 码点（比16位大，用两个 JavaScript 字符编码）的字符串：
+
+```js
+const str = 'x\uD83D\uDE80y';
+
+// ES5: \uD83D\uDE80 are (incorrectly) reversed
+console.log(str.split('').reverse().join(''));
+ // 'y\uDE80\uD83Dx'
+
+// ES6: order of \uD83D\uDE80 is preserved
+console.log([...str].reverse().join(''));
+ // 'y\uD83D\uDE80x'
+```
+
+在火狐浏览器中的翻转结果：
+
+![](http://exploringjs.com/es6/images/strings----firefox_unicode_strings.jpg)
+
+> 遗留问题：合并标记
+> 一个*合并标记*就是两个 Unicode 码点的序列，用于展示单个符号。我在这里展示的 ES6 翻转非 BMP 码点的方法，不适用于合并标记。对于合并标记的翻转，你需要一个库，例如 Mathias Bynens 的 [Esrever](https://github.com/mathiasbynens/esrever) 。

md/6/6.3.md

@@ -0,0 +1,29 @@
+## 6.5 码点的数字值
+
+新方法 `codePointAt()` 返回字符串中指定位置字符的数字值：
+
+```js
+const str = 'x\uD83D\uDE80y';
+console.log(str.codePointAt(0).toString(16)); // 78
+console.log(str.codePointAt(1).toString(16)); // 1f680
+console.log(str.codePointAt(3).toString(16)); // 79
+```
+
+该方法在字符串遍历中也能正确执行：
+
+```js
+for (const ch of 'x\uD83D\uDE80y') {
+ console.log(ch.codePointAt(0).toString(16));
+}
+// Output:
+// 78
+// 1f680
+// 79
+```
+
+与 `codePointAt()` 对应的方法是 `String.fromCodePoint()` ：
+
+```
+> String.fromCodePoint(0x78, 0x1f680, 0x79) === 'x\uD83D\uDE80y'
+true
+```

md/6/6.4.md

@@ -0,0 +1,26 @@
+## 6.6 检查子串
+
+有三个方法用于检查某个字符串是否是另一个字符串的子串：
+
+```
+> 'hello'.startsWith('hell')
+true
+> 'hello'.endsWith('ello')
+true
+> 'hello'.includes('ell')
+true
+```
+
+每个方法都有可选的第二个参数，用于指定字符串搜索的开始或者结束位置：
+
+```
+> 'hello'.startsWith('ello', 1)
+true
+> 'hello'.endsWith('hell', 4)
+true
+
+> 'hello'.includes('ell', 1)
+true
+> 'hello'.includes('ell', 2)
+false
+```

md/6/6.5.md

@@ -0,0 +1,8 @@
+## 6.7 重复字符串
+
+`repeat()` 方法用于生成重复字符串：
+
+```
+> 'doo '.repeat(3)
+'doo doo doo '
+```

md/6/6.6.md

@@ -0,0 +1,10 @@
+## 6.8 用正则表达式作为参数的字符串方法
+
+在 ES6 中，四个用正则表达式作为参数的字符串方法做的事情相当少，它们主要调用参数上面的方法：
+
+* `String.prototype.match(regexp)` 调用 `regexp[Symbol.match](this)`。
+* `String.prototype.replace(searchValue, replaceValue)` 调用 `searchValue[Symbol.replace](this, replaceValue)` 。
+* `String.prototype.search(regexp)` 调用 `regexp[Symbol.search](this)` 。
+* `String.prototype.split(separator, limit)` 调用 `separator[Symbol.split](this, limit)` 。
+
+这些参数根本不需要是正则表达式，任何带有相应方法的对象都可以作为参数。