离线下载
PDF版 ePub版

阮一峰 · 更新于 2018-11-28 11:00:43

字符串的扩展

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 函数或者垫片模块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)是增强版的字符串,用反引号(&#96;)标识。它可以当作普通字符串使用,也可以用来定义多行字符串,或者在字符串中嵌入变量。

// 普通字符串
`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, "&amp;")
            .replace(/</g, "&lt;")
            .replace(/>/g, "&gt;");

    // 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);
上一篇: 变量的解构赋值 下一篇: 数值的扩展