16.字符串

const str1 = 'abc';
const str2 = "abc";
assert.equal(str1, str2);

• 字符串插值
• 多行
• 原始字符串字面值（反斜杠没有特殊含义）

• Unix 换行符：'\n'
• Windows 换行符：'\r\n'
• 标签：'\t'
• 反斜杠：'\\'

'She said: "Let\'s go!"'
"She said: \"Let's go!\""

const str = 'abc';
// Reading a character at a given index
assert.equal(str[1], 'b');
// Counting the characters in a string:
assert.equal(str.length, 3);

for (const ch of 'abc') {
  console.log(ch);
}
// Output:
// 'a'
// 'b'
// 'c'

assert.deepEqual([...'abc'], ['a', 'b', 'c']);

assert.equal(3 + ' times ' + 4, '3 times 4');

let str = ''; // must be `let`!
str += 'Say it';
str += ' one more';
str += ' time';
assert.equal(str, 'Say it one more time');

• String(x)
• ''+x
• x.toString()（对undefined和null不起作用）

assert.equal(String(undefined), 'undefined');
assert.equal(String(null), 'null');
assert.equal(String(false), 'false');
assert.equal(String(true), 'true');
assert.equal(String(123.45), '123.45');

> String(false)
'false'
> Boolean('false')
true

> String({a: 1})
'[object Object]'

> String(['a', 'b'])
'a,b'
> String(['a', ['b']])
'a,b'
> String([1, 2])
'1,2'
> String(['1', '2'])
'1,2'
> String([true])
'true'
> String(['true'])
'true'
> String(true)
'true'

> String(function f() {return 4})
'function f() {return 4}'

const obj = {
  toString() {
    return 'hello';
  }
};
assert.equal(String(obj), 'hello');

> JSON.stringify({a: 1})
'{"a":1}'
> JSON.stringify(['a', ['b']])
'["a",["b"]]'

console.log(JSON.stringify({first: 'Jane', last: 'Doe'}, null, 2));

{
  "first": "Jane",
  "last": "Doe"
}

< <= > >=

> 'A' < 'B' // ok
true
> 'a' < 'B' // not ok
false
> 'ä' < 'b' // not ok
false

• 代码点：Unicode 字符，范围为 21 位。
• UTF-16 代码单元：JavaScript 字符，范围为 16 位。代码点编码为 1-2 个 UTF-16 代码单元。
• 字形簇：字素 是书面符号，显示在屏幕或纸上。字形簇 是编码字素的 1 个或多个代码点的序列。

// 3 Unicode code points, 3 JavaScript characters:
assert.equal('abc'.length, 3);
// 1 Unicode code point, 2 JavaScript characters:
assert.equal('🙂'.length, 2);

> '\u{1F642}'
'🙂'

> String.fromCodePoint(0x1F642)
'🙂'

> '🙂'.codePointAt(0).toString(16)
'1f642'

const str = '🙂a';
assert.equal(str.length, 3);
for (const codePoint of str) {
  console.log(codePoint);
}
// Output:
// '🙂'
// 'a'

> [...'🙂a']
[ '🙂', 'a' ]

> [...'🙂a'].length
2
> '🙂a'.length
3

> '\uD83D\uDE42'
'🙂'

> String.fromCharCode(0xD83D) + String.fromCharCode(0xDE42)
'🙂'

> '🙂'.charCodeAt(0).toString(16)
'd83d'

• 字符代码： 使用数值表示 JavaScript 字符，Unicode 代码单元的 JavaScript 名称
  • String.fromCharCode()，String.prototype.charCodeAt()
  • 精度：16 位，无符号
• 代码点： 使用数值表示 Unicode 字符
  • String.fromCodePoint()，String.prototype.codePointAt()
  • 精度：21 位，无符号（17 个平面，每个 16 位）

// Access characters via []
const str = 'abc';
assert.equal(str[1], 'b');
// Concatenate strings via +
assert.equal('a' + 'b' + 'c', 'abc');
assert.equal('take ' + 3 + ' oranges', 'take 3 oranges');

• .endsWith(searchString: string, endPos=this.length): boolean ^[ES6]^ 如果字符串的长度为endPos的子串以searchString结束，则返回true。否则返回false。

  > 'foo.txt'.endsWith('.txt')
  true
  > 'abcde'.endsWith('cd', 4)
  true
  

• .includes(searchString: string, startPos=0): boolean ^[ES6]^ 如果字符串包含searchString，则返回true，否则为false。搜索从startPos开始。

  > 'abc'.includes('b')
  true
  > 'abc'.includes('b', 2)
  false
  

• .indexOf(searchString: string, minIndex=0): number ^[ES1]^ 返回字符串中searchString出现的最低索引，否则返回-1。任何返回的索引都是minIndex或更高。

  > 'abab'.indexOf('a')
  0
  > 'abab'.indexOf('a', 1)
  2
  > 'abab'.indexOf('c')
  - 1
  

• .lastIndexOf(searchString: string, maxIndex=Infinity): number ^[ES1]^ 返回字符串中出现searchString的最高索引，否则返回-1。任何返回的索引都是maxIndex或更低。

  > 'abab'.lastIndexOf('ab', 2)
  2
  > 'abab'.lastIndexOf('ab', 1)
  0
  > 'abab'.lastIndexOf('ab')
  2
  

• .match(regExp: string | RegExp): RegExpMatchArray | null ^[ES3]^ 如果regExp是未设置标志/g的正则表达式，则.match()返回字符串中regExp的第一个匹配项。或者如果没有匹配项则为null。如果regExp是字符串，则在执行前面的步骤之前，它用于创建正则表达式。 结果具有以下类型：

  interface RegExpMatchArray extends Array<string> {
    index: number;
    input: string;
    groups: undefined | {
      [key: string]: string
    };
  }
  

  编号捕获组成为数组索引。 命名捕获组（ES2018）成为.groups的属性。在此模式下，.match()的作用类似于RegExp.prototype.exec()。 例子：

  > 'ababb'.match(/a(b+)/)
  { 0: 'ab', 1: 'b', index: 0, input: 'ababb', groups: undefined }
  > 'ababb'.match(/a(?<foo>b+)/)
  { 0: 'ab', 1: 'b', index: 0, input: 'ababb', groups: { foo: 'b' } }
  > 'abab'.match(/x/)
  null
  

• .match(regExp: RegExp): string[] | null ^[ES3]^ 如果设置了regExp的标志/g，.match()将返回一个包含所有匹配项的数组，如果没有匹配项则返回null。

  > 'ababb'.match(/a(b+)/g)
  [ 'ab', 'abb' ]
  > 'ababb'.match(/a(?<foo>b+)/g)
  [ 'ab', 'abb' ]
  > 'abab'.match(/x/g)
  null
  

• .search(regExp: string | RegExp): number ^[ES3]^ 返回字符串中regExp出现的索引。如果regExp是字符串，则用于创建正则表达式。

  > 'a2b'.search(/[0-9]/)
  1
  > 'a2b'.search('[0-9]')
  1
  

• .startsWith(searchString: string, startPos=0): boolean ^[ES6]^ 如果searchString出现字符串中索引startPos处，则返回true。否则返回false。

  > '.gitignore'.startsWith('.')
  true
  > 'abcde'.startsWith('bc', 1)
  true
  

• .slice(start=0, end=this.length): string ^[ES3]^ 返回从索引start开始（包括）并以索引end结束（不包括）的字符串的子串。您可以使用负指数，其中-1表示this.length-1（以此类推）。

  > 'abc'.slice(1, 3)
  'bc'
  > 'abc'.slice(1)
  'bc'
  > 'abc'.slice(-2)
  'bc'
  

• .split(separator: string | RegExp, limit?: number): string[] ^[ES3]^ 将字符串拆分为子字符串数组 - 分隔符之间出现的字符串。分隔符可以是字符串或正则表达式。正则表达式中的捕获组包含在结果中。

  > 'abc'.split('')
  [ 'a', 'b', 'c' ]
  > 'a | b | c'.split('|')
  [ 'a ', ' b ', ' c' ]
  > 'a : b : c'.split(/ *: */)
  [ 'a', 'b', 'c' ]
  > 'a : b : c'.split(/( *):( *)/)
  [ 'a', ' ', ' ', 'b', ' ', ' ', 'c' ]
  

• .substring(start: number, end=this.length): string ^[ES1]^ 使用.slice()代替此方法。 .substring()未在旧引擎中一致地实现，并且不支持负指数。

• .concat(...strings: string[]): string ^[ES3]^ 返回字符串和strings的连接。 'a'+'b'相当于'a'.concat('b')，更简洁。

  > 'ab'.concat('cd', 'ef', 'gh')
  'abcdefgh'
  

• .padEnd(len: number, fillString=' '): string ^[ES2017]^ 将fillString追加到字符串，直到它具有所需的长度len。

  > '#'.padEnd(2)
  '# '
  > 'abc'.padEnd(2)
  'abc'
  > '#'.padEnd(5, 'abc')
  '#abca'
  

• .padStart(len: number, fillString=' '): string ^[ES2017]^ 将fillString添加到字符串头部，直到它具有所需的长度len。

  > '#'.padStart(2)
  ' #'
  > 'abc'.padStart(2)
  'abc'
  > '#'.padStart(5, 'abc')
  'abca#'
  

• .repeat(count=0): string ^[ES6]^ 返回一个字符串，重复count次。

  > '*'.repeat()
  ''
  > '*'.repeat(3)
  '***'
  

• .normalize(form: 'NFC'|'NFD'|'NFKC'|'NFKD' = 'NFC'): string ^[ES6]^ 根据 Unicode 规范化形式规范化字符串。
• .replace(searchValue: string | RegExp, replaceValue: string): string ^[ES3]^ 将searchValue的匹配项替换为replaceValue。如果searchValue是一个字符串，则只替换第一个出现位置。如果searchValue是没有标志/g的正则表达式，则仅替换第一个匹配项。如果searchValue是带有/g的正则表达式，则替换所有匹配项。

  > 'x.x.'.replace('.', '#')
  'x#x.'
  > 'x.x.'.replace(/./, '#')
  '#.x.'
  > 'x.x.'.replace(/./g, '#')
  '####'
  

  replaceValue中的特殊字符是：* $$：成为$
  • $n：成为编号捕获组n（唉，$0不起作用）
  • $&：成为完全匹配项
  • `$``：成为匹配项前的任何东西
  • $'：成为匹配项后的任何东西 例子：

  > 'a 2020-04 b'.replace(/([0-9]{4})-([0-9]{2})/, '|$2|')
  'a |04| b'
  > 'a 2020-04 b'.replace(/([0-9]{4})-([0-9]{2})/, '|$&|')
  'a |2020-04| b'
  > 'a 2020-04 b'.replace(/([0-9]{4})-([0-9]{2})/, '|$`|')
  'a |a | b'
  

  也支持命名捕获组（ES2018）：* $<name>成为命名捕获组`name

  > 'a 2020-04 b'.replace(/(?<year>[0-9]{4})-(?<month>[0-9]{2})/, '|$<month>|')
  'a |04| b'
  

• .replace(searchValue: string | RegExp, replacer: (...args: any[]) => string): string ^[ES3]^ 如果第二个参数是函数，则替换为其返回的字符串。其参数args是：
  • matched: string：完全匹配项
  • g1: string|undefined：编号捕获组 1
  • g2: string|undefined：编号捕获组 2
  • （等等）
  • offset: number：在输入字符串中找到匹配项的位置？
  • input: string：整个输入字符串

  const regexp = /([0-9]{4})-([0-9]{2})/;
  const replacer = (all, year, month) => '|' + all + '|';
  assert.equal(
    'a 2020-04 b'.replace(regexp, replacer),
    'a |2020-04| b');
  

  也支持命名捕获组（ES2018）。如果有，则最后一个参数包含一个对象，其属性包含捕获组：

  const regexp = /(?<year>[0-9]{4})-(?<month>[0-9]{2})/;
  const replacer = (...args) => {
    const groups=args.pop();
    return '|' + groups.month + '|';
  };
  assert.equal(
    'a 2020-04 b'.replace(regexp, replacer),
    'a |04| b');
  

• .toUpperCase(): string ^[ES1]^ 返回字符串的副本，其中所有小写字母字符都转换为大写。对于各种字母表的效果取决于 JavaScript 引擎。

  > '-a2b-'.toUpperCase()
  '-A2B-'
  > 'αβγ'.toUpperCase()
  'ΑΒΓ
  

• .toLowerCase(): string ^[ES1]^ 返回字符串的副本，其中所有大写字母字符都转换为小写。对于各种字母表的效果取决于 JavaScript 引擎。

  > '-A2B-'.toLowerCase()
  '-a2b-'
  > 'ΑΒΓ'.toLowerCase()
  'αβγ'
  

• .trim(): string ^[ES5]^ 返回字符串的副本，其中所有前导和尾随空白（空格，制表符，行终止符等）都去掉了。

  > '\r\n#\t  '.trim()
  '#'
  

• .trimEnd(): string ^[ES2019]^ 与.trim()类似，但仅修剪字符串的末尾：

  > '  abc  '.trimEnd()
  '  abc'
  

• .trimStart(): string ^[ES2019]^ 与.trim()类似，但仅修剪字符串的开头：

  > '  abc  '.trimStart()
  'abc  '
  

• .charAt(pos: number): string ^[ES1]^ 返回索引pos处的字符，作为字符串（JavaScript 没有字符的数据类型）。 str[i]等同于str.charAt(i)并且更简洁（警告：可能不适用于旧引擎）。

  > 'abc'.charAt(1)
  'b'
  

• .charCodeAt(pos: number): number ^[ES1]^ 返回索引pos处的 UTF-16 代码单元（字符）的 16 位数字（0-65535）。

  > 'abc'.charCodeAt(1)
  98
  

• .codePointAt(pos: number): number | undefined ^[ES6]^ 返回索引pos处 1-2 个字符的 Unicode 代码点的 21 位数。如果没有这样的索引，则返回undefined。

• TypeScript 的内置类型
• JavaScript 的 MDN 网络文档
• ECMAScript 语言规范