字符串的新增方法

String.fromCodePoint()

​ ES5提供String.fromCharCode()方法，用于从Unicode码点返回对应字符，但是这个方法不能识别码点大于0xFFFF的字符。会发生溢出，导致最高位被舍弃。

​ ES6提供了String.fromCodePoint()方法，用于从Unicode码点返回对应字符，可识别大于0xFFFF的字符，弥补了String.fromCharCode()方法的不足。如果String.fromCodePoint方法有多个参数，则它们会被合并成一个字符串返回。

​ String.fromCodePoint.codePointAt()：返回字符串中指定位置的字符的Unicode码点。

fromCodePoint和codePointAt的区别：

• fromCodePoint方法定义在String对象上，而codePointAt方法定义在字符串的实例对象上。
• fromCodePoint()用来从码点创建一个新的字符串，codePointAt()用来获取特定位置的码点值。

String.fromCodePoint(0x20BB7) // 返回 "𠮷"
String.fromCodePoint(0x78, 0x1f680, 0x79) === 'x\uD83D\uDE80y' // true
let str = '𠮷'; let firstChar = str.codePointAt(0); // 返回 134071

String.raw()

​ 用于创建原始字符串，返回一个斜杠都被转义(即斜杠前面再加一个斜杠)的字符串，往往用于模板字符串的处理方法。这个方法返回一个原始字符串，不会对反斜杠进行转义，这意味着在原始字符串中，反斜杠被视为普通字符，而不是转义字符。可以作为处理模板字符串的基本方法，它会将所有变量替换，并对斜杠进行转义，方便下一步作为字符串来使用。主要用于模板字面量中，当你想要生成原始字符串时。

String.raw`Hi\n${2+3}!` // 实际返回 "Hi\\n5!"，显示的是转义后的结果 "Hi\n5!"
String.raw`Hi\u000A!`; // 实际返回 "Hi\\u000A!"，显示的是转义后的结果 "Hi\u000A!"
//如果原字符串的斜杠已经转义，那么String.raw()会进行再次转义。
String.raw`Hi\\n` // 返回 "Hi\\\\n"
String.raw`Hi\\n` === "Hi\\\\n" // true

​ String.raw()本质上是一个正常的函数，只是专用于模板字符串的标签函数。如果写成正常函数的形式，第一个参数应该是一个具有raw属性的对象，且raw属性的值应该是一个数组，对应模板字符串解析后的值。

// `foo${1 + 2}bar`
// 等同于
String.raw({ raw: ['foo', 'bar'] }, 1 + 2) // "foo3bar" 第一个参数是一个对象，它的raw属性等同于原始的模板字符串解析后得到的数组

实例方法：codePointAt()

​ 在JavaScript内部，字符以UTF-16的格式储存，每个字符固定为2个字节。对于那些需要4个字节储存的字符(Unicode码点大于0xFFFF的字符)，JavaScript不能正确处理，字符串长度会误判为2，而且charAt()方法无法读取整个字符，charCodeAt()方法只能分别返回前两个字节和后两个字节的值。

​ ES6提供了codePointAt()方法，能正确处理 4个字节储存的字符，返回一个字符的码点，该方法会正确返回32位的UTF-16字符的码点，对于那些两个字节储存的常规字符，它的返回结果与charCodeAt()方法相同。codePointAt()方法返回的是码点的十进制值，如果想要十六进制的值，可以使用toString()方法转换一下。

let s = '𠮷a';
s.codePointAt(0).toString(16) // "20bb7"
s.codePointAt(2).toString(16) // "61"
//字符a在字符串s的正确位置序号应该是1，但是必须向codePointAt()方法传入 2。因为'𠮷'占了0和1位。

​ 解决这个问题的一个办法是使用for...of循环，因为它会正确识别32位的UTF-16字符。

let s = '𠮷a';
for (let ch of s) {
  console.log(ch.codePointAt(0).toString(16));
}
// 20bb7
// 61

​ 另一种方法是使用扩展运算符（...）进行展开运算。

let arr = [...'𠮷a']; // arr.length === 2
arr.forEach(
  ch => console.log(ch.codePointAt(0).toString(16))
);
// 20bb7
// 61

​ codePointAt()方法是测试一个字符由两个字节还是由四个字节组成的最简单方法。

function is32Bit(c) {
  return c.codePointAt(0) > 0xFFFF;
}
is32Bit("𠮷") // true
is32Bit("a") // false

实例方法：normalize()

​ ES6提供字符串实例normalize()方法，用来将字符的不同表示方法统一为同样的形式，这称为Unicode正规化。

'\u01D1'.normalize() === '\u004F\u030C'.normalize()  // true

Unicode定义了四种规范化形式：NFC、NFD、NFKC和NFKD：

• ****NFC****（Normalization Form Canonical Composition）：标准等价合成。默认参数。返回多个简单字符的合成字符。所谓标准等价指的是视觉和语义上的等价。例如，"é" 会被转换为 "e\u0301"。
• ****NFD****（Normalization Form Canonical Decomposition）：标准等价分解。在标准等价的前提下，返回合成字符分解的多个简单字符。例如，字符串"no-break space"会被转换为两个空格字符。
• ****NFKC****（Normalization Form Compatibility Composition）：兼容等价合成。返回合成字符，兼容等价指的是语义上存在等价，但视觉上不等价，比如“囍”和“喜喜”。(这只是用来举例，normalize方法不能识别中文)。例如，"滑雪" 这个词会被转换为 "🎿"
• ****NFKD****（Normalization Form Compatibility Decomposition）：兼容等价分解。在兼容等价的前提下，返回合成字符分解的多个简单字符。例如，"滑雪"这个词在会被分解为 "雪" 和 "橇"。

'\u004F\u030C'.normalize('NFC').length // 1  NFC参数返回字符的合成形式
'\u004F\u030C'.normalize('NFD').length // 2  NFD参数返回字符的分解形式

​ normalize方法目前不能识别三个或三个以上字符的合成。这种情况下，还是只能使用正则表达式，通过Unicode编号区间判断。

实例方法：includes(), startsWith(), endsWith()

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

​ 这三个方法都支持第二个参数，表示开始搜索的位置。使用第二个参数n时，endsWith的行为与其他两个方法有所不同，它针对前n个字符，而其他两个方法针对从第n个位置直到字符串结束。

let s = 'Hello world!';
s.startsWith('world', 6) // true
s.endsWith('Hello', 5) // true
s.includes('Hello', 6) // false

实例方法：repeat()

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

• 参数是小数，会被取整（向下取整）。例如，'na'.repeat(2.9) // "nana"
• 参数是负数或者Infinity，会报错。
• 参数是 0 到-1 之间的小数，则等同于 0，这是因为会先进行取整运算。0 到-1 之间的小数取整以后等于-0，repeat视同为 0。
• 参数NaN等同于 0。
• 参数是字符串，则会先转换成数字。

实例方法：padStart()，padEnd()

​ ES2017引入了字符串补全长度的功能。如果某个字符串不够指定长度，会在头部或尾部补全。padStart()用于头部补全，padEnd()用于尾部补全。padStart()和padEnd()一共接受两个参数，第一个参数是字符串补全生效的最大长度，第二个参数是用来补全的字符串。

• 如果原字符串的长度等于或大于最大长度，则字符串补全不生效，返回原字符串。
• 如果用来补全的字符串与原字符串，两者的长度之和超过了最大长度，则会截去超出位数的补全字符串。
• 如果省略第二个参数，默认使用空格补全长度。
• padStart()的常见用途是为数值补全指定位数。另一个用途是提示字符串格式。

'xxx'.padStart(2, 'ab') // 'xxx'
'abc'.padStart(10, '0123456789')// '0123456abc'
'x'.padEnd(4) // 'x   '
'12'.padStart(10, '0') // "0000000012"
'12'.padStart(10, 'YYYY-MM-DD') // "YYYY-MM-12"

实例方法：trimStart()，trimEnd()

​ ES2019对字符串实例新增了trimStart()和trimEnd()方法。它们的行为与trim()一致，trimStart()消除字符串头部的空格，trimEnd()消除尾部的空格。它们返回的都是新字符串，不会修改原始字符串。除了空格键，这两个方法对字符串头部(或尾部)的tab键、换行符等不可见的空白符号也有效。浏览器还部署了额外的两个方法，trimLeft()是trimStart()的别名，trimRight()是trimEnd()的别名。

const s = '  abc  ';
s.trim() // "abc"
s.trimStart() // "abc  "
s.trimEnd() // "  abc"

实例方法：matchAll()

​ matchAll()方法返回一个正则表达式在当前字符串的所有匹配。它返回一个迭代器，包含了字符串中所有与正则表达式匹配的结果。这个方法主要用于处理字符串中的多行匹配。

const regex = /a/g; //全局匹配 "a" 的正则表达式  
const str = 'abacaba';  

const matches = str.matchAll(regex);//返回一个迭代器,包含字符串'abacaba'中所有匹配regex的结果
for (const match of matches) {  
  console.log(match);  
}

实例方法：replaceAll()

​ 字符串的实例方法replace()只能替换第一个匹配，如果要替换所有的匹配，不得不使用正则表达式的g修饰符。正则表达式毕竟不是那么方便和直观，ES2021引入了replaceAll()方法，可以一次性替换所有匹配。它的用法与replace()相同，返回一个新字符串，不会改变原字符串。

• String.prototype.replaceAll(searchValue, replacement)接受两个必需的参数：
  • searchValue: 搜索模式，要在字符串中查找的值。可以是一个字符串，或是一个全局的正则表达式(带有g修饰符)。
  • replacement: 替换的文本，用于替换找到的每个匹配项的值。可以是一个字符串，或是一个函数。其中可以使用一些特殊字符串，如$&、$` 、$'、$n等。

'aabbcc'.replace(/b/, '_') //不报错
'aabbcc'.replaceAll(/b/, '_') //报错，/b/不带有g修饰符，会导致replaceAll()报错

const str = "apple, banana, cherry";  
//match参数表示当前找到的匹配项,使用它，可以为每个匹配项执行自定义操作，然后返回一个替换值。
const newStr = str.replaceAll("banana", (match) => {  
  return match.toUpperCase();  
});  
console.log(newStr); // 输出: "apple, BANANA, cherry"

​ 这个替换函数可以接受多个参数。第一个参数是捕捉到的匹配内容，第二个参数捕捉到是组匹配（有多少个组匹配，就有多少个对应的参数）。最后还可以添加两个参数，倒数第二个参数是捕捉到的内容在整个字符串中的位置，最后一个参数是原字符串。

const str = '123abc456';
const regex = /(\d+)([a-z]+)(\d+)/g;
//match：捕捉到的匹配内容(123abc456)。p1：第一个捕获组。p2：第二个捕获组。p3：第三个捕获组。offset：匹配开始的位置。string：原始字符串。
function replacer(match, p1, p2, p3, offset, string) {
  return [p1, p2, p3].join(' - '); // 替换为 p1 - p2 - p3 的形式
}
str.replaceAll(regex, replacer) // 123 - abc - 456

实例方法：at()

​ at()方法接受一个整数作为参数，返回参数指定位置的字符，支持负索引（即倒数的位置）。如果参数位置超出了字符串范围，at()返回undefined。

const str = 'hello';
str.at(1) // "e"
str.at(-1) // "o"
str.at(6) // "undefined"