ES6 加强了对 Unicode 的支持，并且扩展了字符串对象。
codePointAt()
JavaScript 内部，字符以 UTF-16 的格式储存，每个字符固定为 2 个字节。对于那些需要 4 个字节储存的字符（Unicode 码点大于 0xFFFF 的字符），JavaScript 会认为它们是两个字符。
var s = "𠮷"; s.length // 2 s.charAt(0) // '' s.charAt(1) // '' s.charCodeAt(0) // 55362 s.charCodeAt(1) // 57271
上面代码中，汉字“𠮷”的码点是 0x20BB7，UTF-16 编码为 0xD842 0xDFB7（十进制为 55362 57271），需要 4 个字节储存。对于这种 4 个字节的字符，JavaScript 不能正确处理，字符串长度会误判为 2，而且 charAt 方法无法读取字符，charCodeAt 方法只能分别返回前两个字节和后两个字节的值。
ES6 提供了 codePointAt 方法，能够正确处理 4 个字节储存的字符，返回一个字符的码点。
var s = "𠮷a"; s.codePointAt(0) // 134071 s.codePointAt(1) // 57271 s.charCodeAt(2) // 97
codePointAt 方法的参数，是字符在字符串中的位置（从 0 开始）。上面代码中，JavaScript 将“𠮷a”视为三个字符，codePointAt 方法在第一个字符上，正确地识别了“𠮷”，返回了它的十进制码点 134071（即十六进制的20BB7）。在第二个字符（即“𠮷”的后两个字节）和第三个字符“a”上，codePointAt 方法的结果与 charCodeAt 方法相同。
总之，codePointAt 方法会正确返回四字节的 UTF-16 字符的码点。对于那些两个字节储存的常规字符，它的返回结果与 charCodeAt 方法相同。
codePointAt 方法是测试一个字符由两个字节还是由四个字节组成的最简单方法。
function is32Bit(c) { return c.codePointAt(0) > 0xFFFF; } is32Bit("𠮷") // true is32Bit("a") // false
String.fromCodePoint()
ES5 提供 String.fromCharCode 方法，用于从码点返回对应字符，但是这个方法不能识别辅助平面的字符（编号大于 0xFFFF）。
String.fromCharCode(0x20BB7) // "ஷ"
上面代码中，最后返回码点 U+0BB7 对应的字符，而不是码点 U+20BB7 对应的字符。
ES6 提供了 String.fromCodePoint 方法，可以识别 0xFFFF 的字符，弥补了 String.fromCharCode 方法的不足。在作用上，正好与 codePointAt 方法相反。
String.fromCodePoint(0x20BB7) // "𠮷"
注意，fromCodePoint 方法定义在 String 对象上，而 codePointAt 方法定义在字符串的实例对象上。
String.prototype.at()
ES5 提供 String.prototype.charAt 方法，返回字符串给定位置的字符。该方法不能识别码点大于 0xFFFF 的字符。
'𠮷'.charAt(0) // '\uD842'
上面代码中，charAt 方法返回的是 UTF-16 编码的第一个字节，实际上是无法显示的。
ES7 提供了字符串实例的 at 方法，可以识别 Unicode 编号大于 0xFFFF 的字符，返回正确的字符。
'𠮷'.at(0) // '𠮷'
字符的 Unicode 表示法
JavaScript 允许采用“\uxxxx”形式表示一个字符，其中“xxxx”表示字符的码点。
"\u0061" // "a"
但是，这种表示法只限于\u0000——\uFFFF之间的字符。超出这个范围的字符，必须用两个双字节的形式表达。
"\uD842\uDFB7" // "𠮷" "\u20BB7" // " 7"
上面代码表示，如果直接在“\u”后面跟上超过 0xFFFF 的数值（比如 \u20BB7），JavaScript 会理解成“\u20BB+7”。由于\u20BB是一个不可打印字符，所以只会显示一个空格，后面跟着一个 7。
ES6 对这一点做出了改进，只要将码点放入大括号，就能正确解读该字符。
"\u{20BB7}" // "𠮷" "\u{41}\u{42}\u{43}" // "ABC"
正则表达式的 u 修饰符
ES6 对正则表达式添加了 u 修饰符，用来正确处理大于\uFFFF的 Unicode 字符。
（1）点字符
点（.）字符在正则表达式中，解释为除了换行以外的任意单个字符。对于码点大于 0xFFFF 的 Unicode 字符，点字符不能识别，必须加上 u 修饰符。
var s = "𠮷"; /^.$/.test(s) // false /^.$/u.test(s) // true
上面代码表示，如果不添加 u 修饰符，正则表达式就会认为字符串为两个字符，从而匹配失败。
（2）Unicode字符表示法
ES6 新增了使用大括号表示 Unicode 字符，这种表示法在正则表达式中必须加上 u 修饰符，才能识别。
/\u{61}/.test('a') // false /\u{61}/u.test('a') // true /\u{20BB7}/u.test('𠮷') // true
上面代码表示，如果不加 u 修饰符，正则表达式无法识别\u{61}这种表示法，只会认为这匹配 61 个连续的 u。
（3）量词
使用 u 修饰符后，所有量词都会正确识别大于码点大于 0xFFFF 的 Unicode 字符。
/a{2}/.test('aa') // true /a{2}/u.test('aa') // true /𠮷{2}/.test('𠮷𠮷') // false /𠮷{2}/u.test('𠮷𠮷') // true
（4）预定义模式
u 修饰符也影响到预定义模式，能否正确识别码点大于 0xFFFF 的 Unicode 字符。
/^\S$/.test('𠮷') // false /^\S$/u.test('𠮷')
上面代码的\S是预定义模式，匹配所有不是空格的字符。只有加了 u 修饰符，它才能正确匹配码点大于 0xFFFF 的 Unicode 字符。
利用这一点，可以写出一个正确返回字符串长度的函数。
function codePointLength(text) { var result = text.match(/[\s\S]/gu); return result ? result.length : 0; } var s = "𠮷𠮷"; s.length // 4 codePointLength(s) // 2
（5）i 修饰符
有些 Unicode 字符的编码不同，但是字型很相近，比如，\u004B与\u212A都是大写的 K。
/[a-z]/i.test('\u212A') // false /[a-z]/iu.test('\u212A') // true
上面代码中，不加 u 修饰符，就无法识别非规范的 K 字符。
normalize()
为了表示语调和重音符号，Unicode 提供了两种方法。一种是直接提供带重音符号的字符，比如Ǒ（\u01D1）。另一种是提供合成符号（combining character），即原字符与重音符号的合成，两个字符合成一个字符，比如O（\u004F）和ˇ（\u030C）合成Ǒ（\u004F\u030C）。
这两种表示方法，在视觉和语义上都等价，但是 JavaScript 不能识别。
'\u01D1'==='\u004F\u030C' //false '\u01D1'.length // 1 '\u004F\u030C'.length // 2
上面代码表示，JavaScript 将合成字符视为两个字符，导致两种表示方法不相等。
ES6 提供 String.prototype.normalize()方法，用来将字符的不同表示方法统一为同样的形式，这称为 Unicode 正规化。
'\u01D1'.normalize() === '\u004F\u030C'.normalize() // true
normalize 方法可以接受四个参数。
- NFC，默认参数，表示“标准等价合成”（Normalization Form Canonical Composition），返回多个简单字符的合成字符。所谓“标准等价”指的是视觉和语义上的等价。
- NFD，表示“标准等价分解”（Normalization Form Canonical Decomposition），即在标准等价的前提下，返回合成字符分解的多个简单字符。
- NFKC，表示“兼容等价合成”（Normalization Form Compatibility Composition），返回合成字符。所谓“兼容等价”指的是语义上存在等价，但视觉上不等价，比如“囍”和“喜喜”。
- NFKD，表示“兼容等价分解”（Normalization Form Compatibility Decomposition），即在兼容等价的前提下，返回合成字符分解的多个简单字符。
'\u004F\u030C'.normalize('NFC').length // 1 '\u004F\u030C'.normalize('NFD').length // 2
上面代码表示，NFC 参数返回字符的合成形式，NFD 参数返回字符的分解形式。
不过，normalize 方法目前不能识别三个或三个以上字符的合成。这种情况下，还是只能使用正则表达式，通过 Unicode 编号区间判断。
includes(), startsWith(), endsWith()
传统上，JavaScript 只有 indexOf 方法，可以用来确定一个字符串是否包含在另一个字符串中。ES6 又提供了三种新方法。
- includes()：返回布尔值，表示是否找到了参数字符串。
- startsWith()：返回布尔值，表示参数字符串是否在源字符串的头部。
- endsWith()：返回布尔值，表示参数字符串是否在源字符串的尾部。
var s = "Hello world!"; s.startsWith("Hello") // true s.endsWith("!") // true s.includes("o") // true
这三个方法都支持第二个参数，表示开始搜索的位置。
var s = "Hello world!"; s.startsWith("world", 6) // true s.endsWith("Hello", 5) // true s.includes("Hello", 6) // false
上面代码表示，使用第二个参数 n 时，endsWith 的行为与其他两个方法有所不同。它针对前 n 个字符，而其他两个方法针对从第 n 个位置直到字符串结束。
repeat()
repeat()返回一个新字符串，表示将原字符串重复 n 次。
"x".repeat(3) // "xxx" "hello".repeat(2) // "hellohello"
正则表达式的 y 修饰符
除了 u 修饰符，ES6 还为正则表达式添加了 y 修饰符，叫做“粘连”（sticky）修饰符。它的作用与 g 修饰符类似，也是全局匹配，后一次匹配都从上一次匹配成功的下一个位置开始，不同之处在于，g 修饰符只要剩余位置中存在匹配就可，而 y 修饰符确保匹配必须从剩余的第一个位置开始，这也就是“粘连”的涵义。
var s = "aaa_aa_a"; var r1 = /a+/g; var r2 = /a+/y; r1.exec(s) // ["aaa"] r2.exec(s) // ["aaa"] r1.exec(s) // ["aa"] r2.exec(s) // null
上面代码有两个正则表达式，一个使用 g 修饰符，另一个使用 y 修饰符。这两个正则表达式各执行了两次，第一次执行的时候，两者行为相同，剩余字符串都是“_aa_a”。由于 g 修饰没有位置要求，所以第二次执行会返回结果，而 y 修饰符要求匹配必须从头部开始，所以返回 null。
如果改一下正则表达式，保证每次都能头部匹配，y 修饰符就会返回结果了。
var s = "aaa_aa_a"; var r = /a+_/y; r.exec(s) // ["aaa_"] r.exec(s) // ["aa_"]
上面代码每次匹配，都是从剩余字符串的头部开始。
进一步说，y 修饰符号隐含了头部匹配的标志ˆ。
/b/y.exec("aba") // null
上面代码由于不能保证头部匹配，所以返回 null。y 修饰符的设计本意，就是让头部匹配的标志ˆ在全局匹配中都有效。
与 y 修饰符相匹配，ES6 的正则对象多了 sticky 属性，表示是否设置了 y 修饰符。
var r = /hello\d/y; r.sticky // true
Regexp.escape()
字符串必须转义，才能作为正则模式。
function escapeRegExp(str) { return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"); } let str = '/path/to/resource.html?search=query'; escapeRegExp(str) // "\/path\/to\/resource\.html\?search=query"
上面代码中，str 是一个正常字符串，必须使用反斜杠对其中的特殊字符转义，才能用来作为一个正则匹配的模式。
已经有Regexp.escape()，放入 ES7。
RegExp.escape("The Quick Brown Fox"); // "The Quick Brown Fox" RegExp.escape("Buy it. use it. break it. fix it.") // "Buy it\. use it\. break it\. fix it\." RegExp.escape("(*.*)"); // "\(\*\.\*\)"
字符串转义以后，可以使用 RegExp 构造函数生成正则模式。
var str = 'hello. how are you?'; var regex = new RegExp(RegExp.escape(str), 'g'); assert.equal(String(regex), '/hello\. how are you\?/g');
目前，该方法可以用上文的 escapeRegExp 函数或者垫片模块<a rel="nofollow" href="https://github.com/ljharb/regexp.escape" "="" style="box-sizing: border-box; color: rgb(45, 133, 202); background-color: transparent;">regexp.escape实现。
var escape = require('regexp.escape'); escape('hi. how are you?') "hi\\. how are you\\?"
模板字符串
传统的 JavaScript 语言，输出模板通常是这样写的。
$("#result").append( "There are <b>" + basket.count + "</b> " + "items in your basket, " + "<em>" + basket.onSale + "</em> are on sale!" );
上面这种写法相当繁琐不方便，ES6 引入了模板字符串解决这个问题。
$("#result").append(` There are <b>${basket.count}</b> items in your basket, <em>${basket.onSale}</em> are on sale! `);
模板字符串（template string）是增强版的字符串，用反引号（`）标识。它可以当作普通字符串使用，也可以用来定义多行字符串，或者在字符串中嵌入变量。
// 普通字符串 `In JavaScript '\n' is a line-feed.` // 多行字符串 `In JavaScript this is not legal.` console.log(`string text line 1 string text line 2`); // 字符串中嵌入变量 var name = "Bob", time = "today"; `Hello ${name}, how are you ${time}?`
上面代码中的字符串，都是用反引号表示。如果在模板字符串中需要使用反引号，则前面要用反斜杠转义。
var greeting = `\`Yo\` World!`;
如果使用模板字符串表示多行字符串，所有的空格和缩进都会被保留在输出之中。
$("#warning").html(` <h1>Watch out!</h1> <p>Unauthorized hockeying can result in penalties of up to ${maxPenalty} minutes.</p> `);
模板字符串中嵌入变量，需要将变量名写在${}之中。
function authorize(user, action) { if (!user.hasPrivilege(action)) { throw new Error( // 传统写法为 // 'User ' // + user.name // + ' is not authorized to do ' // + action // + '.' `User ${user.name} is not authorized to do ${action}.`); } }
大括号内部可以放入任意的 JavaScript 表达式，可以进行运算，以及引用对象属性。
var x = 1; var y = 2; console.log(`${x} + ${y} = ${x+y}`) // "1 + 2 = 3" console.log(`${x} + ${y*2} = ${x+y*2}`) // "1 + 4 = 5" var obj = {x: 1, y: 2}; console.log(`${obj.x + obj.y}`) // 3
模板字符串之中还能调用函数。
function fn() { return "Hello World"; } console.log(`foo ${fn()} bar`); // foo Hello World bar
如果大括号中的值不是字符串，将按照一般的规则转为字符串。不如，大括号中是一个对象，将默认调用对象的 toString 方法。
如果模板字符串中的变量没有声明，将报错。
// 变量place没有声明 var msg = `Hello, ${place}`; // 报错
标签模板
模板字符串的功能，不仅仅是上面这些。它可以紧跟在一个函数名后面，该函数将被调用来处理这个模板字符串。这被称为“标签模板”功能（tagged template）。
var a = 5; var b = 10; tag`Hello ${ a + b } world ${ a * b }`;
上面代码中，模板字符串前面有一个标识名 tag，它是一个函数。整个表达式的返回值，就是 tag 函数处理模板字符串后的返回值。
函数 tag 依次会接收到多个参数。
function tag(stringArr, value1, value2){ // ... } // 等同于 function tag(stringArr, ...values){ // ... }
tag 函数的第一个参数是一个数组，该数组的成员是模板字符串中那些没有变量替换的部分，也就是说，变量替换只发生在数组的第一个成员与第二个成员之间、第二个成员与第三个成员之间，以此类推。
tag 函数的其他参数，都是模板字符串各个变量被替换后的值。由于本例中，模板字符串含有两个变量，因此tag会接受到 value1 和 value2 两个参数。
tag 函数所有参数的实际值如下。
- 第一个参数：['Hello ', ' world ']
- 第二个参数: 15
- 第三个参数：50
也就是说，tag 函数实际上以下面的形式调用。
tag(['Hello ', ' world '], 15, 50)
我们可以按照需要编写 tag 函数的代码。下面是 tag 函数的一种写法，以及运行结果。
var a = 5; var b = 10; function tag(s, v1, v2) { console.log(s[0]); console.log(s[1]); console.log(v1); console.log(v2); return "OK"; } tag`Hello ${ a + b } world ${ a * b}`; // "Hello " // " world " // 15 // 50 // "OK"
下面是一个更复杂的例子。
var total = 30; var msg = passthru`The total is ${total} (${total*1.05} with tax)`; function passthru(literals) { var result = ""; var i = 0; while (i < literals.length) { result += literals[i++]; if (i < arguments.length) { result += arguments[i]; } } return result; } msg // "The total is 30 (31.5 with tax)"
上面这个例子展示了，如何将各个参数按照原来的位置拼合回去。
passthru 函数采用 rest 参数的写法如下。
function passthru(literals,...values) { var output = ""; for (var index = 0; index < values.length; index++) { output += literals[index] + values[index]; } output += literals[index] return output; }
“标签模板”的一个重要应用，就是过滤 HTML 字符串，防止用户输入恶意内容。
var message = SaferHTML`<p>${sender} has sent you a message.</p>`; function SaferHTML(templateData) { var s = templateData[0]; for (var i = 1; i < arguments.length; i++) { var arg = String(arguments[i]); // Escape special characters in the substitution. s += arg.replace(/&/g, "&") .replace(/</g, "<") .replace(/>/g, ">"); // Don't escape special characters in the template. s += templateData[i]; } return s; }
上面代码中，经过 SaferHTML 函数处理，HTML 字符串的特殊字符都会被转义。
标签模板的另一个应用，就是多语言转换（国际化处理）。
i18n`Hello ${name}, you have ${amount}:c(CAD) in your bank account.` // Hallo Bob, Sie haben 1.234,56 $CA auf Ihrem Bankkonto.
模板字符串本身并不能取代 Mustache 之类的模板函数，因为没有条件判断和循环处理功能，但是通过标签函数，你可以自己添加这些功能。
// 下面的hashTemplate函数 // 是一个自定义的模板处理函数 var libraryHtml = hashTemplate` <ul> #for book in ${myBooks} <li><i>#{book.title}</i> by #{book.author}</li> #end </ul> `;
除此之外，你甚至可以使用标签模板，在 JavaScript 语言之中嵌入其他语言。
java` class HelloWorldApp { public static void main(String[] args) { System.out.println(“Hello World!”); // Display the string. } } ` HelloWorldApp.main();
模板处理函数的第一个参数（模板字符串数组），还有一个 raw 属性。
tag`First line\nSecond line` function tag(strings) { console.log(strings.raw[0]); // "First line\\nSecond line" }
上面代码中，tag 函数的第一个参数 strings，有一个 raw 属性，也指向一个数组。该数组的成员与 strings 数组完全一致。比如，strings数组是["First line\nSecond line"]，那么 strings.raw 数组就是["First line\\nSecond line"]。两者唯一的区别，就是字符串里面的斜杠都被转义了。比如，strings.raw 数组会将\n视为\和n两个字符，而不是换行符。这是为了方便取得转义之前的原始模板而设计的。
String.raw()
ES6 还为原生的 String 对象，提供了一个 raw 方法。
String.raw 方法，往往用来充当模板字符串的处理函数，返回一个斜杠都被转义（即斜杠前面再加一个斜杠）的字符串，对应于替换变量后的模板字符串。
String.raw`Hi\n${2+3}!`; // "Hi\\n5!" String.raw`Hi\u000A!`; // 'Hi\\u000A!'
它的代码基本如下。
String.raw = function (strings,...values) { var output = ""; for (var index = 0; index < values.length; index++) { output += strings.raw[index] + values[index]; } output += strings.raw[index] return output; }
String.raw 方法可以作为处理模板字符串的基本方法，它会将所有变量替换，而且对斜杠进行转义，方便下一步作为字符串来使用。
String.raw 方法也可以作为正常的函数使用。这时，它的第一个参数，应该是一个具有 raw 属性的对象，且 raw 属性的值应该是一个数组。
String.raw({ raw: 'test' }, 0, 1, 2); // 't0e1s2t' // 等同于 String.raw({ raw: ['t','e','s','t'] }, 0, 1, 2);
