字符串的扩展

字符的 Unicode 表示法#

JavaScript 允许采用\uxxxx形式表示一个字符，其中xxxx表示字符的 Unicode 码点。

1
    '\u0061'
2
    // "a"

但是，这种表示法只限于码点在\u0000~\uFFFF之间的字符。超出这个范围的字符，必须用两个双字节的形式表示

ES6 对这一点做出了改进，只要将码点放入大括号，就能正确解读该字符

1
    '\u{20BB7}'
2
    // "𠮷"
3

4
    '\u{41}\u{42}\u{43}'
5
    // "ABC"
6

7
    let hello = 123
8
    hello // 123
9

10
    '\u{1F680}' === '\uD83D\uDE80'
11
    // true

上面代码中，最后一个例子表明，大括号表示法与四字节的 UTF-16 编码是等价的。

有了这种表示法之后，JavaScript 共有 6 种方法可以表示一个字符

1
    'z' === 'z' // true
2
    '\172' === 'z' // true
3
    '\x7A' === 'z' // true
4
    '\u007A' === 'z' // true
5
    '\u{7A}' === 'z' // true

codePointAt()#

JavaScript 内部，字符以 UTF-16 的格式储存，每个字符固定为2个字节。对于那些需要4个字节储存的字符(Unicode 码点大于0xFFFF的字符)，JavaScript 会认为它们是两个字符

1
    var s = '𠮷'
2

3
    s.length // 2
4
    s.charAt(0) // ''
5
    s.charAt(1) // ''
6
    s.charCodeAt(0) // 55362
7
    s.charCodeAt(1) // 57271

上面代码中，汉字“𠮷”(注意，这个字不是“吉祥”的“吉”)的码点是0x20BB7，UTF-16 编码为0xD842 0xDFB7(十进制为55362 57271)，需要4个字节储存。对于这种4个字节的字符，JavaScript 不能正确处理，字符串长度会误判为2，而且charAt方法无法读取整个字符，charCodeAt方法只能分别返回前两个字节和后两个字节的值

ES6 提供了codePointAt方法，能够正确处理 4 个字节储存的字符，返回一个字符的码点。

1
    let s = '𠮷a'
2

3
    s.codePointAt(0) // 134071
4
    s.codePointAt(1) // 57271
5

6
    s.codePointAt(2) // 97

codePointAt方法的参数，是字符在字符串中的位置(从 0 开始)。上面代码中，JavaScript 将“𠮷 a”视为三个字符，codePointAt 方法在第一个字符上，正确地识别了“𠮷”，返回了它的十进制码点 134071(即十六进制的20BB7)。在第二个字符(即“𠮷”的后两个字节)和第三个字符“a”上，codePointAt方法的结果与charCodeAt方法相同。

总之，codePointAt方法会正确返回 32 位的 UTF-16 字符的码点。对于那些两个字节储存的常规字符，它的返回结果与charCodeAt方法相同。

codePointAt方法返回的是码点的十进制值，如果想要十六进制的值，可以使用toString方法转换一下。

1
    let s = '𠮷a'
2

3
    s.codePointAt(0).toString(16) // "20bb7"
4
    s.codePointAt(2).toString(16) // "61"

您可能注意到了，codePointAt方法的参数，仍然是不正确的。比如，上面代码中，字符a在字符串s的正确位置序号应该是 1，但是必须向codePointAt方法传入 2。解决这个问题的一个办法是使用for...of循环，因为它会正确识别 32 位的 UTF-16 字符

1
    let s = '𠮷a'
2
    for (let ch of s) {
3
        console.log(ch.codePointAt(0).toString(16))
4
    }
5
    // 20bb7
6
    // 6

String.fromCodePoint()#

ES5 提供String.fromCharCode方法，用于从码点返回对应字符，但是这个方法不能识别 32 位的 UTF-16 字符(Unicode 编号大于0xFFFF)。

1
    String.fromCharCode(0x20bb7)
2
    // "ஷ"

上面代码中，String.fromCharCode不能识别大于0xFFFF的码点，所以0x20BB7就发生了溢出，最高位2被舍弃了，最后返回码点U+0BB7对应的字符，而不是码点U+20BB7对应的字符。

ES6 提供了String.fromCodePoint方法，可以识别大于0xFFFF的字符，弥补了String.fromCharCode方法的不足。在作用上，正好与codePointAt方法相反。

1
  String.fromCodePoint(0x20bb7)
2
  // "𠮷"
3
  String.fromCodePoint(0x78, 0x1f680, 0x79) === "x\uD83D\uDE80y"
4
  // true

上面代码中，如果String.fromCodePoint方法有多个参数，则它们会被合并成一个字符串返回。

注意，fromCodePoint方法定义在String对象上，而codePointAt方法定义在字符串的实例对象上

字符串的遍历器接口#

ES6 为字符串添加了遍历器接口，使得字符串可以被for...of循环遍历。

1
    for (let codePoint of 'foo') {
2
        console.log(codePoint)
3
    }
4
    // "f"
5
    // "o"
6
    // "o"

除了遍历字符串，这个遍历器最大的优点是可以识别大于0xFFFF的码点，传统的for循环无法识别这样的码点

1
    let text = String.fromCodePoint(0x20bb7)
2

3
    for (let i = 0; i < text.length; i++) {
4
        console.log(text[i])
5
    }
6
    // " "
7
    // " "
8

9
    for (let i of text) {
10
        console.log(i)
11
    }
12
    // "𠮷"

上面代码中，字符串text只有一个字符，但是for循环会认为它包含两个字符(都不可打印)，而for...of循环会正确识别出这一个字符

includes(), startsWith(), endsWith()#

传统上，JavaScript 只有indexOf方法，可以用来确定一个字符串是否包含在另一个字符串中。 ES6 又提供了三种新方法。

includes(): 返回布尔值，表示是否找到了参数字符串。
startsWith(): 返回布尔值，表示参数字符串是否在原字符串的头部。

endsWith(): 返回布尔值，表示参数字符串是否在原字符串的尾部

1
let s = 'Hello world!'
2

3
s.startsWith('Hello') // true
4
s.endsWith('!') // true
5
s.includes('o') // true

这三个方法都支持第二个参数，表示开始搜索的位置

1
    let s = 'Hello world!'
2

3
    s.startsWith('world', 6) // true
4
    s.endsWith('Hello', 5) // true
5
    s.includes('Hello', 6) // false

上面代码表示，使用第二个参数n时，endsWith的行为与其他两个方法有所不同。它针对前n个字符，而其他两个方法针对从第n个位置直到字符串结束

repeat()#

repeat方法返回一个新字符串，表示将原字符串重复n次。

1
    'x'.repeat(3) // "xxx"
2
    'hello'.repeat(2) // "hellohello"
3
    'na'.repeat(0) // ""

参数如果是小数，会被取整。

1
  "na".repeat(2.9) // "nana"

如果repeat的参数是负数或者Infinity，会报错

1
    'na'.repeat(Infinity)
2
    // RangeError
3
    'na'.repeat(-1)
4
    // RangeError

但是，如果参数是 0 到-1 之间的小数，则等同于 0，这是因为会先进行取整运算。0 到-1 之间的小数，取整以后等于-0，repeat视同为 0

1
  "na".repeat(-0.9) // ""

参数NaN等同于 0。

1
  "na".repeat(NaN) // ""

如果repeat的参数是字符串，则会先转换成数字。

1
  "na".repeat("na") // ""
2
  "na".repeat("3") // "nanana"

padStart()，padEnd()#

ES2017 引入了字符串补全长度的功能。如果某个字符串不够指定长度，会在头部或尾部补全。 padStart()用于头部补全，padEnd()用于尾部补全

1
  "x".padStart(5, "ab") // 'ababx'
2
  "x".padStart(4, "ab") // 'abax'
3

4
  "x".padEnd(5, "ab") // 'xabab'
5
  "x".padEnd(4, "ab") // 'xaba'

上面代码中，padStart和padEnd一共接受两个参数，第一个参数用来指定字符串的最小长度，第二个参数是用来补全的字符串。

如果原字符串的长度，等于或大于指定的最小长度，则返回原字符串

1
    'xxx'.padStart(2, 'ab') // 'xxx'
2
    'xxx'.padEnd(2, 'ab') // 'xxx'

如果用来补全的字符串与原字符串，两者的长度之和超过了指定的最小长度，则会截去超出位数的补全字符串

1
    'abc'.padStart(10, '0123456789')
2
    // '0123456abc'

如果省略第二个参数，默认使用空格补全长度

1
    'x'.padStart(4) // '   x'
2
    'x'.padEnd(4) // 'x   '

padStart的常见用途是为数值补全指定位数。下面代码生成 10 位的数值字符串

1
    '1'.padStart(10, '0') // "0000000001"
2
    '12'.padStart(10, '0') // "0000000012"
3
    '123456'.padStart(10, '0') // "0000123456"

另一个用途是提示字符串格式。

1
    '12'.padStart(10, 'YYYY-MM-DD') // "YYYY-MM-12"
2
    '09-12'.padStart(10, 'YYYY-MM-DD') // "YYYY-09-12"

matchAll()#

matchAll方法返回一个正则表达式在当前字符串的所有匹配

模板字符串#

传统的 JavaScript 语言，输出模板通常是这样写的(下面使用了 jQuery 的方法)。

1
    $('#result').append(
2
        'There are <b>' +
3
            basket.count +
4
            '</b> ' +
5
            'items in your basket, ' +
6
            '<em>' +
7
            basket.onSale +
8
            '</em> are on sale!'
9
    )

上面这种写法相当繁琐不方便，ES6 引入了模板字符串解决这个问题。

1
    $('#result').append(`
2
        There are <b>${basket.count}</b> items
3
        in your basket, <em>${basket.onSale}</em>
4
        are on sale!
5
    `)

模板字符串(template string)是增强版的字符串，用反引号(```)标识。它可以当作普通字符串使用，也可以用来定义多行字符串，或者在字符串中嵌入变量

1
    // 普通字符串
2
    ;`In JavaScript '\n' is a line-feed.` // 多行字符串
3
    `In JavaScript this is not legal.`
4

5
    console.log(`string text line 1 string text line 2`)
6

7
    // 字符串中嵌入变量
8
    let name = 'Bob',
9
        time = 'today'
10
    ;`Hello ${name}, how are you ${time}?`
11
    // Hello Bob, how are you today?

上面代码中的模板字符串，都是用反引号表示。如果在模板字符串中需要使用反引号，则前面要用反斜杠转义。

1
  let greeting = `\`Yo\` World!`

如果使用模板字符串表示多行字符串，所有的空格和缩进都会被保留在输出之中。

1
  $("#list").html(`
2
  <ul>
3
    <li>first</li>
4
    <li>second</li>
5
  </ul>
6
  `)

上面代码中，所有模板字符串的空格和换行，都是被保留的，比如<ul>标签前面会有一个换行。如果您不想要这个换行，可以使用trim方法消除它

1
  $("#list").html(
2
    `
3
  <ul>
4
    <li>first</li>
5
    <li>second</li>
6
  </ul>
7
  `.trim()
8
  )

模板字符串中嵌入变量，需要将变量名写在${}之中。

1
    function authorize(user, action) {
2
        if (!user.hasPrivilege(action)) {
3
            throw new Error(
4
                // 传统写法为
5
                // 'User '
6
                // + user.name
7
                // + ' is not authorized to do '
8
                // + action
9
                // + '.'
10
                `User ${user.name} is not authorized to do ${action}.`
11
            )
12
        }
13
    }

大括号内部可以放入任意的 JavaScript 表达式，可以进行运算，以及引用对象属性。

1
    let x = 1
2
    let y = 2
3

4
    ;`${x} + ${y} = ${x + y}` // "1 + 2 = 3"
5
    `${x} + ${y * 2} = ${x + y * 2}`
6
    // "1 + 4 = 5"
7

8
    let obj = { x: 1, y: 2 }
9
    ;`${obj.x + obj.y}`
10
    // "3"

模板字符串之中还能调用函数。

1
    function fn() {
2
        return 'Hello World'
3
    }
4

5
    ;`foo ${fn()} bar`
6
    // foo Hello World bar

如果大括号中的值不是字符串，将按照一般的规则转为字符串。比如，大括号中是一个对象，将默认调用对象的toString方法

如果模板字符串中的变量没有声明，将报错。

1
  // 变量place没有声明
2
  let msg = `Hello, ${place}`
3
  // 报错

由于模板字符串的大括号内部，就是执行 JavaScript 代码，因此如果大括号内部是一个字符串，将会原样输出

1
  `Hello ${"World"}`
2
  // "Hello World"

标签模板#

模板字符串的功能，不仅仅是上面这些。它可以紧跟在一个函数名后面，该函数将被调用来处理这个模板字符串。这被称为“标签模板”功能(tagged template)。

1
    alert`123`
2
    // 等同于
3
    alert(123)

标签模板其实不是模板，而是函数调用的一种特殊形式。“标签”指的就是函数，紧跟在后面的模板字符串就是它的参数。

但是，如果模板字符里面有变量，就不是简单的调用了，而是会将模板字符串先处理成多个参数，再调用函数。

1
    let a = 5
2
    let b = 10
3

4
    tag`Hello ${a + b} world ${a * b}`
5
    // 等同于
6
    tag(['Hello ', ' world ', ''], 15, 50)

上面代码中，模板字符串前面有一个标识名tag，它是一个函数。整个表达式的返回值，就是tag函数处理模板字符串后的返回值。

函数tag依次会接收到多个参数。

1
    function tag(stringArr, value1, value2) {
2
        // ...
3
    }
4

5
    // 等同于
6

7
    function tag(stringArr, ...values) {
8
        // ...
9
    }

tag函数的第一个参数是一个数组，该数组的成员是模板字符串中那些没有变量替换的部分，也就是说，变量替换只发生在数组的第一个成员与第二个成员之间、第二个成员与第三个成员之间，以此类推。

tag函数的其他参数，都是模板字符串各个变量被替换后的值。由于本例中，模板字符串含有两个变量，因此tag会接受到value1和value2两个参数。

tag函数所有参数的实际值如下。

第一个参数: [‘Hello ’, ’ world ’, ”]
第二个参数: 15
第三个参数: 50

也就是说，tag函数实际上以下面的形式调用。

1
  tag(["Hello ", " world ", ""], 15, 50)

我们可以按照需要编写tag函数的代码。下面是tag函数的一种写法，以及运行结果。

1
    let a = 5
2
    let b = 10
3

4
    function tag(s, v1, v2) {
5
        console.log(s[0])
6
        console.log(s[1])
7
        console.log(s[2])
8
        console.log(v1)
9
        console.log(v2)
10

11
        return 'OK'
12
    }
13

14
    tag`Hello ${a + b} world ${a * b}`
15
    // "Hello "
16
    // " world "
17
    // ""
18
    // 15
19
    // 50
20
    // "OK"

“标签模板”的一个重要应用，就是过滤 HTML 字符串，防止用户输入恶意内容。

1
    let message = SaferHTML`<p>${sender} has sent you a message.</p>`
2

3
    function SaferHTML(templateData) {
4
        let s = templateData[0]
5
        for (let i = 1; i < arguments.length; i++) {
6
            let arg = String(arguments[i])
7

8
            // Escape special characters in the substitution.
9
            s += arg
10
                .replace(/&/g, '&amp;')
11
                .replace(/</g, '&lt;')
12
                .replace(/>/g, '&gt;')
13

14
            // Don't escape special characters in the template.
15
            s += templateData[i]
16
        }
17
        return s
18
    }

上面代码中，sender变量往往是用户提供的，经过SaferHTML函数处理，里面的特殊字符都会被转义。

1
  let sender = '<script>alert("abc")</script>' // 恶意代码
2
  let message = SaferHTML`<p>${sender} has sent you a message.</p>`
3

4
  message
5
  // <p>&lt;script&gt;alert("abc")&lt;/script&gt; has sent you a message.</p>

String.raw()#

ES6 还为原生的 String 对象，提供了一个raw方法。

String.raw方法，往往用来充当模板字符串的处理函数，返回一个斜杠都被转义(即斜杠前面再加一个斜杠)的字符串，对应于替换变量后的模板字符串

1
    String.raw`Hi\n${2 + 3}!`
2
    // 返回 "Hi\\n5!"
3

4
    String.raw`Hi\u000A!`
5
    // 返回 "Hi\\u000A!"

如果原字符串的斜杠已经转义，那么String.raw会进行再次转义。

1
  String.raw`Hi\\n`
2
  // 返回 "Hi\\\\n"

String.raw方法可以作为处理模板字符串的基本方法，它会将所有变量替换，而且对斜杠进行转义，方便下一步作为字符串来使用。

String.raw方法也可以作为正常的函数使用。这时，它的第一个参数，应该是一个具有raw属性的对象，且raw属性的值应该是一个数组。

1
    String.raw({ raw: 'test' }, 0, 1, 2)
2
    // 't0e1s2t'
3

4
    // 等同于
5
    String.raw({ raw: ['t', 'e', 's', 't'] }, 0, 1, 2)

作为函数，String.raw的代码实现基本如下

1
    String.raw = function (strings, ...values) {
2
        let output = ''
3
        let index
4
        for (index = 0; index < values.length; index++) {
5
            output += strings.raw[index] + values[index]
6
        }
7

8
        output += strings.raw[index]
9
        return output
10
    }

模板字符串的限制#

前面提到标签模板里面，可以内嵌其他语言。但是，模板字符串默认会将字符串转义，导致无法嵌入其他语言。

举例来说，标签模板里面可以嵌入 LaTEX 语言。

1
    function latex(strings) {
2
        // ...
3
    }
4

5
    let document = latex`
6
        \newcommand{\fun}{\textbf{Fun!}}  // 正常工作
7
        \newcommand{\unicode}{\textbf{Unicode!}} // 报错
8
        \newcommand{\xerxes}{\textbf{King!}} // 报错
9

10
        Breve over the h goes \u{h}ere // 报错
11
        `

上面代码中，变量document内嵌的模板字符串，对于 LaTEX 语言来说完全是合法的，但是 JavaScript 引擎会报错。原因就在于字符串的转义。

模板字符串会将\u00FF和\u{42}当作 Unicode 字符进行转义，所以解析\unicode时报错；而\x56会被当作十六进制字符串转义，所以\xerxes会报错。也就是说，\u和\x在 LaTEX 里面有特殊含义，但是 JavaScript 将它们转义了。

为了解决这个问题，ES2018 放松了对标签模板里面的字符串转义的限制。如果遇到不合法的字符串转义，就返回undefined，而不是报错，并且从raw属性上面可以得到原始字符串。

1
    function tag(strs) {
2
        strs[0] === undefined
3
        strs.raw[0] === '\\unicode and \\u{55}'
4
    }
5
    tag`\unicode and \u{55}`

上面代码中，模板字符串原本是应该报错的，但是由于放松了对字符串转义的限制，所以不报错了，JavaScript 引擎将第一个字符设置为undefined，但是raw属性依然可以得到原始字符串，因此tag函数还是可以对原字符串进行处理。

注意，这种对字符串转义的放松，只在标签模板解析字符串时生效，不是标签模板的场合，依然会报错

1
  let bad = `bad escape sequence: \unicode` // 报错