String ​

字符串是 JavaScript 的一种基本的数据类型。

构造函数 ​

• new String() 构造函数创建的是 String 对象。
• String()当作为函数调用时，它返回的是String类型的原始值。

静态方法 ​

静态方法的语法只能固定以 String.静态方法 的使用。

String.fromCharCode() ​

• 描述：根据指定的 UTF-16 码元序列创建的字符串。
• 参数：接收一个或多个由介于 0 和 65535（0xFFFF） 之间的数表示的 UTF-16 码元。（参数为负数其实也可以，约束松散）。
• 异常：如果大于0xFFFF则会从 0x后面开始截断并忽略，如：0xAFFF1，这里的 A 会被截掉，最终为0xFFF1。

String.fromCodePoint()推荐 ​

• 描述：根据指定的码位序列返回一个字符串。
• 参数：Unicode 码位范围从 0 到 1114111（0x10FFFF）。
• 异常：如果 参数 不是整数、小于 0 或者在转换为数字后大于 0x10FFFF，则会抛出该异常。

String.raw() ​

• 语法：

String.raw`templateString`
String.raw(strings, ...substitutions)

String.raw`templateString`
String.raw(strings, ...substitutions)

• 描述：它用于获取模板字符串的原始字符串形式（没有被转义前的样子）。 表达式（例如 ${foo}）会被替换处理，但转义序列（例如 \n）不会被处理。String.raw 是唯一 一个内置的模板字符串标签函数。
• 参数（strings）：格式正确的模板字符串数组对象，应该是一个具有 raw 属性的对象，其值是一个类数组的字符串对象。例如 { raw: ['foo', 'bar', 'baz'] }。
• 可选参数（substitutions）：包含的替换表达式对应的值。

// 特殊的 \ \f,\n,\r,\v 都是有一定意义的，使用String.raw，可以避免转义。
const filePath1 = String.raw`C:\Development\aboutme.html`; // C:\Development\aboutme.html (原始)
const filePath2 = `C:\Development\aboutme.html`; // C:Developmentaboutme.html ( \ 被转义) 

// 函数传参
String.raw({ raw: "test" }, 0, 1, 2); // 't0e1s2t'

// 还可以应用于一些数学、物理、化学公式表达

// 特殊的 \ \f,\n,\r,\v 都是有一定意义的，使用String.raw，可以避免转义。
const filePath1 = String.raw`C:\Development\aboutme.html`; // C:\Development\aboutme.html (原始)
const filePath2 = `C:\Development\aboutme.html`; // C:Developmentaboutme.html ( \ 被转义) 

// 函数传参
String.raw({ raw: "test" }, 0, 1, 2); // 't0e1s2t'

// 还可以应用于一些数学、物理、化学公式表达

实例方法 ​

实例方法就是写在String.prototype上的方法。

String.prototype.at() ​

• 描述：接受一个整数值（正/负），并返回一个新的 String 。
• 参数：要返回的字符串字符的索引（位置）。当传递负数时，支持从字符串末端开始的相对索引 。调用时参数会被隐式转为number类型的整数，当结果为NaN时，默认返回索引为 0 对应的字符
• 返回：由位于指定位置的单个 UTF-16 码元组成的 String。如果找不到指定的索引，则返回 undefined 。

String.prototype.charAt() ​

• 描述：返回一个由给定索引处的单个 UTF-16 码元构成的新字符串。
• 参数：从零开始的正整数，字符的索引。调用时参数会被隐式转为number类型的整数，当结果为NaN时，默认返回索引为 0 对应的字符。
• 返回：由位于指定位置的单个 UTF-16 码元组成的 String。如果找不到指定的索引，则返回 空字符串 。

String.prototype.charCodeAt() ​

• 描述：获取索引处的 UTF-16 码元。（其值介于 0 和 65535 （0xFFFF）之间）
• 参数：字符的索引，从零开始的正整数。调用时参数会被隐式转为number类型的整数，当结果为NaN时，默认返回索引为 0 对应的字符。
• 返回： UTF-16 码元。如果找不到指定的索引，则返回 NaN 。

String.prototype.codePointAt()推荐 ​

• 描述：获取索引处的字符的 Unicode 码位值（Unicode 码位范围从 0 到 1114111（0x10FFFF）。
• 参数：字符的索引，从零开始的正整数。调用时参数会被隐式转为number类型的整数，当结果为NaN时，默认返回索引为 0 对应的字符。
• 返回：

  Unicode 码位值，如果找不到指定的索引，则返回 undefined。

  如果 index 处的元素是一个 UTF-16 前导代理（leading surrogate），则返回代理对的码位。

  如果 index 处的元素是一个 UTF-16 后尾代理（trailing surrogate），则只返回后尾代理的码元。

const str = "\ud83d\udc0e\ud83d\udc71\u2764";

// 不推荐
for (let i = 0; i < str.length; i++) {
  console.log(str.codePointAt(i).toString(16));
}
// '1f40e'、'dc0e'、'1f471'、'dc71'、'2764'

// 推荐
for (const codePoint of str) {
  console.log(codePoint.codePointAt(0).toString(16));
}
// '1f40e'、'1f471'、'2764'

// 推荐
[...str].map((cp) => cp.codePointAt(0).toString(16));
// ['1f40e', '1f471', '2764']

const str = "\ud83d\udc0e\ud83d\udc71\u2764";

// 不推荐
for (let i = 0; i < str.length; i++) {
  console.log(str.codePointAt(i).toString(16));
}
// '1f40e'、'dc0e'、'1f471'、'dc71'、'2764'

// 推荐
for (const codePoint of str) {
  console.log(codePoint.codePointAt(0).toString(16));
}
// '1f40e'、'1f471'、'2764'

// 推荐
[...str].map((cp) => cp.codePointAt(0).toString(16));
// ['1f40e', '1f471', '2764']

String.prototype.concat() ​

• 描述：方法将一个或多个字符串连接到调用的字符串，并返回一个新的字符串，不会影响原字符串。

String.prototype.startsWith() ​

• 描述：方法用来判断当前字符串是否以另外一个给定的子字符串开头，并根据判断结果返回 true 或 false。
• 参数：要在该字符串开头搜索的子串。不能是正则表达式。所有不是正则表达式的值都会被强制转换为字符串，省略或传入 undefined，该方法会在字符串中搜索 "undefined"。
• [可选参数]：指定搜索到哪个位置结束。 默认为 str.length
• 异常：参数不能是正则表达式，否则会抛出异常。

String.prototype.endsWith() ​

• 描述：方法用于判断一个字符串是否以指定字符串结尾。返回 true / false。
• 参数：以指定结尾的字符串，传入的参数强制转换为字符串，省略或传入 undefined，该方法会在字符串中搜索 "undefined"。
• [可选参数]：指定从什么位置开始。 默认为 0。
• 异常：参数不能是正则表达式，否则会抛出异常。

String.prototype.includes() ​

• 描述：方法执行区分大小写的搜索，以确定是否可以在一个字符串中找到另一个字符串，并根据情况返回 true 或 false。
• 参数：searchString（要搜索的字符串），传入的参数强制转换为字符串。省略或传入 undefined，该方法会在字符串中搜索 "undefined"。
• [可选参数]：指定从什么位置开始搜索。默认值为 0。
• 异常：参数不能是正则表达式，否则会抛出异常。

String.prototype.indexOf() ​

• 描述：方法在字符串中搜索指定子字符串，并返回其第一次出现的位置索引否则返回-1。
• 参数： searchString（要搜索的字符串），传入的参数强制转换为字符串。省略或传入 undefined，该方法会在字符串中搜索 "undefined"。
• [可选参数]：指定从什么位置开始搜索，大于字符串长度则不会搜索，小于0则从0开始搜索。默认值为 0。返回值还是字符串原来位置。

String.prototype.lastIndexOf() ​

• 描述：方法在字符串中搜索指定子字符串，并返回其最后一次出现的位置索引否则返回-1。
• 参数： searchString（要搜索的字符串），传入的参数强制转换为字符串。省略或传入 undefined，该方法会在字符串中搜索 "undefined"。
• [可选参数]：在指定字符串长度范围内搜索，大于字符串长度则全部搜索，小于0则于0相同只搜索0位置。默认值为+Infinity。返回值还是字符串原来位置。

String.prototype.isWellFormed() ​

• 描述：方法返回一个表示该字符串是否包含单独代理项的布尔值。如果字符串不包含单独代理项，返回 true，否则返回 false。
  isWellFormed() 让你能够测试一个字符串是否是格式正确的（即不包含单独代理项）。由于引擎能够直接访问字符串的内部表示，与自定义实现相比 isWellFormed() 更高效。如果你需要将字符串转换为格式正确的字符串，可以使用 toWellFormed() 方法。isWellFormed() 让你可以对格式正确和格式错误的字符串进行不同的处理，比如抛出一个错误或将其标记为无效。

String.prototype.toWellFormed() ​

• 描述：方法返回一个字符串，其中该字符串的所有单独代理项都被替换为 Unicode 替换字符 U+FFFD。toWellFormed() 迭代字符串的码元，并将任何单独代理项替换为 Unicode 替换字符 U+FFFD �。这确保了返回的字符串格式正确并可用于期望正确格式字符串的函数，比如 encodeURI。由于引擎能够直接访问字符串的内部表示，与自定义实现相比 toWellFormed() 更高效。

String.prototype.localeCompare() ​

• 描述：方法返回一个数字，表示参考字符串在排序顺序中是在给定字符串之前、之后还是与之相同。在支持 Intl.Collator API 的实现中，该方法仅是调用了 Intl.Collator 方法。当比较大量字符串时，例如对大型数组进行排序，最好创建一个 Intl.Collator 对象，并使用其 compare() 方法提供的函数。
• 参数：locales 和 options 参数可以自定义函数的行为，并让应用程序指定应使用哪种语言的格式约定。
• [可选参数]：表示缩写语言代码。
• [可选参数]：一个调整输出格式的对象。
• 返回：

  1. 当 referenceStr 在 compareString 前面时返回负数；
     
  2. 当 referenceStr 在 compareString 后面时返回正数；
     
  3. 当两者相等时返回 0；

console.log("ä".localeCompare("z", "de")); // 负值：在德语中，ä 排在 z 之前
console.log("ä".localeCompare("z", "sv")); // 正值：在瑞典语中，ä 排在 z 之后

console.log("ä".localeCompare("z", "de")); // 负值：在德语中，ä 排在 z 之前
console.log("ä".localeCompare("z", "sv")); // 正值：在瑞典语中，ä 排在 z 之后

String.prototype.match() ​

• 描述：方法检索字符串与正则表达式进行匹配的结果。
• 参数：一个正则表达式对象或者任何具有 Symbol.match 方法的对象。如果 regexp 不是 RegExp 对象并且对象上无 Symbol.match 方法，则会使用 new RegExp(regexp) 将其隐式地转换为 RegExp。如果match参数为空则相当于match(/( ? : )/)，配得到[""]
• 返回：
  1. 如果使用 g 标志，则将返回与完整正则表达式匹配的所有结果，但不会返回捕获组。
     
  2. 如果没有使用 g 标志，则只返回第一个完整匹配及其相关捕获组。在这种情况下，match() 方法将返回与 RegExp.prototype.exec() 相同的结果（一个带有一些额外属性的数组）。

String.prototype.matchAll() ​

• 描述：方法返回一个迭代器，该迭代器包含了检索字符串与正则表达式进行匹配的所有结果（包括捕获组）。
• 参数：一个正则表达式对象，或者是任何具有 Symbol.matchAll 方法的对象。正则表达式，必须设置了全局（g）标志。（也会隐式转换RegExp）
• 返回：一个匹配结果的可迭代迭代器对象（它不可重新开始）。每个匹配结果都是一个数组，其形状与 RegExp.prototype.exec() 的返回值相同。
• 异常：如果 regexp 是一个正则表达式，且没有设置全局（g）标志（其 flags 属性不包含 "g"），则会抛出该异常。

const str = "table football, foosball";
const regexp = /foo[a-z]*/g;
const matches = str.matchAll(regexp);

for (const match of matches) {
  console.log(
    `找到 ${match[0]} 起始位置=${match.index} 结束位置=${
      match.index + match[0].length
    }.`,
  );
}
// 找到 football 起始位置=6 结束位置=14.
// 找到 foosball 起始位置=16 结束位置=24.

const str = "table football, foosball";
const regexp = /foo[a-z]*/g;
const matches = str.matchAll(regexp);

for (const match of matches) {
  console.log(
    `找到 ${match[0]} 起始位置=${match.index} 结束位置=${
      match.index + match[0].length
    }.`,
  );
}
// 找到 football 起始位置=6 结束位置=14.
// 找到 foosball 起始位置=16 结束位置=24.

String.prototype.normalize() ​

• 描述：方法返回该字符串的 Unicode 标准化形式。Unicode 为每个字符分配一个唯一的数值，称为码位。抽象字符可以由一个或多个码位或码位序列来表示。
• 参数：
  1. NFC: 规范分解，然后进行规范组合。
     
  2. NFD: 规范分解。
     
  3. NFKC: 兼容分解，然后进行规范组合。
     
  4. NFKD: 规范分解。
     用于指定 Unicode 标准化形式。如果省略或为 undefined，则默认为 "NFC"。
• 异常: 如果 参数 不是上述指定的值之一，将抛出该异常。

let string1 = "\uFB00";//'ff'
let string2 = "\u0066\u0066";//'ff'
string1 = string1.normalize("NFKD"); // 'ff'
string2 = string2.normalize("NFKD"); // 'ff'
string1 === string2 // true

let string1 = "\uFB00";//'ff'
let string2 = "\u0066\u0066";//'ff'
string1 = string1.normalize("NFKD"); // 'ff'
string2 = string2.normalize("NFKD"); // 'ff'
string1 === string2 // true

String.prototype.padEnd() ​

• 描述：方法会将当前字符串从末尾开始填充给定的字符串（如果需要会重复填充），直到达到给定的长度。填充是从当前字符串的末尾开始的。
• 参数：当前 str 填充后的长度。如果该值小于或等于 str.length，则会直接返回当前 str。
• [可选参数]：用于填充当前 str 的字符串。如果 padString 太长，无法适应 targetLength，则会被截断：对于从左到右的语言，左侧的部分将会被保留；对于从右到左的语言，右侧的部分将会被保留。默认值为“ ” (U+0020)。

"abc".padEnd(10); // "abc       "
"abc".padEnd(10, "foo"); // "abcfoofoof"
"abc".padEnd(6, "123456"); // "abc123"
"abc".padEnd(1); // "abc"

"abc".padEnd(10); // "abc       "
"abc".padEnd(10, "foo"); // "abcfoofoof"
"abc".padEnd(6, "123456"); // "abc123"
"abc".padEnd(1); // "abc"

String.prototype.padStart() ​

• 描述：方法用另一个字符串填充当前字符串（如果需要会重复填充），直到达到给定的长度。填充是从当前字符串的开头开始的。
• 参数：当前 str 填充后的长度。如果该值小于或等于 str.length，则会直接返回当前 str。
• [可选参数]：用于填充当前 str 的字符串。如果 padString 太长，无法适应 targetLength，则会从末尾被截断。默认值为 Unicode“空格”字符（U+0020）。

"abc".padStart(10); // "       abc"
"abc".padStart(10, "foo"); // "foofoofabc"
"abc".padStart(6, "123465"); // "123abc"
"abc".padStart(8, "0"); // "00000abc"
"abc".padStart(1); // "abc"

"abc".padStart(10); // "       abc"
"abc".padStart(10, "foo"); // "foofoofabc"
"abc".padStart(6, "123465"); // "123abc"
"abc".padStart(8, "0"); // "00000abc"
"abc".padStart(1); // "abc"

String.prototype.repeat() ​

• 描述：方法构造并返回一个新字符串，其中包含指定数量的所调用的字符串副本，这些副本连接在一起。
• 参数：介于 0 和 +Infinity 之间的整数。表示在新构造的字符串中重复了多少遍原字符串。(向下取整)
• 异常：如果 count 为负值，或者 count 超过了字符串的最大长度，将抛出错误。

"abc".repeat(-1); // RangeError
"abc".repeat(0); // ''
"abc".repeat(1); // 'abc'
"abc".repeat(3.5); // 'abcabcabc'（count 将被转换为整数）

"abc".repeat(-1); // RangeError
"abc".repeat(0); // ''
"abc".repeat(1); // 'abc'
"abc".repeat(3.5); // 'abcabcabc'（count 将被转换为整数）

String.prototype.replace() ​

replace(pattern, replacement)

replace(pattern, replacement)

• 描述：该方法并不改变调用它的字符串本身，而是返回一个新的字符串，其中一个、多个或所有匹配的 pattern 被替换为 replacement。pattern 可以是字符串或 RegExp，replacement 可以是字符串或一个在每次匹配时调用的函数。如果 pattern 是字符串，则只会替换第一个匹配项。原始的字符串不会改变。
• 参数1：可以是字符串或者一个带有 Symbol.replace 方法的对象，典型的例子就是正则表达式。任何没有 Symbol.replace 方法的值都会被强制转换为字符串。
• 参数2：可以是字符串或函数。
  1. 如果是字符串，它将替换由 pattern 匹配的子字符串。支持一些特殊的替换模式，请参阅下面替换字符串可以包括以下特殊替换模式。
  2. 如果是函数，将为每个匹配调用该函数，并将其返回值用作替换文本。下面的指定函数作为替换项部分描述了提供给此函数的参数。

替换字符串可以包括以下特殊替换模式

只有当 pattern 参数是一个 RegExp 对象时，$n 和 $< Name > 才可用。如果 pattern 是字符串，或者相应的捕获组在正则表达式中不存在，则该模式将被替换为一个字面量。如果该组存在但未匹配（因为它是一个分支的一部分），则将用空字符串替换它。

const data = '20240110';
const regexp = /(\d{4})(\d{2})(\d{2})/g
const formatDate = data.replace(regexp,"$1-$2-$3") 
console.log(formatDate) // 2024-01-10

const data = '20240110';
const regexp = /(\d{4})(\d{2})(\d{2})/g
const formatDate = data.replace(regexp,"$1-$2-$3") 
console.log(formatDate) // 2024-01-10

指定函数作为替换项 你可以将第二个参数指定为函数。在这种情况下，匹配完成后将调用该函数。函数的结果（返回值）将用作替换字符串。

const data = '20240110';
const regexp = /(\d{4})(\d{2})(\d{2})/g
const formatDate = data.replace(regexp,($,$1,$2,$3)=>{
    return `${$1}-${$2}-${$3}`
}) 
console.log(formatDate) // 2024-01-10

const data = '20240110';
const regexp = /(\d{4})(\d{2})(\d{2})/g
const formatDate = data.replace(regexp,($,$1,$2,$3)=>{
    return `${$1}-${$2}-${$3}`
}) 
console.log(formatDate) // 2024-01-10

String.prototype.replaceAll() ​

replaceAll(pattern, replacement)

replaceAll(pattern, replacement)

• 描述：方法返回一个新字符串，其中所有匹配 pattern 的部分都被替换为 replacement。pattern 可以是一个字符串或一个 RegExp，replacement 可以是一个字符串或一个在每次匹配时调用的函数。原始字符串保持不变。
• 参数1：可以是一个字符串或一个具有 Symbol.replace 方法的对象，典型的例子是正则表达式。任何没有 Symbol.replace 方法的值都将被强制转换为字符串。如果 pattern 是一个正则表达式，则必须设置全局（g）标志，否则会抛出 TypeError。
• 参数2：可以是一个字符串或一个函数。替换字符串的语义与 String.prototype.replace() 相同。
• 异常：如果 pattern 是一个正则表达式，并且没有设置全局（g）标志（其 flags 属性不包含 "g"），则会抛出该异常。

// 字符串replacement
const string = "Apple Ant Airplane Anchor Animal"
const lowString1 = string.replaceAll('A','a')
console.log(lowString1)  // apple ant airplane anchor animal

// 函数replacement
const lowString2 = string.replaceAll(/(A)/g, (match)=>{
    console.log(match) // A
    return 'a' // A 替换成 a
})
console.log(lowString2) // apple ant airplane anchor animal

// 字符串replacement
const string = "Apple Ant Airplane Anchor Animal"
const lowString1 = string.replaceAll('A','a')
console.log(lowString1)  // apple ant airplane anchor animal

// 函数replacement
const lowString2 = string.replaceAll(/(A)/g, (match)=>{
    console.log(match) // A
    return 'a' // A 替换成 a
})
console.log(lowString2) // apple ant airplane anchor animal

String.prototype.search() ​

• 描述：方法用于在 String 对象中执行正则表达式的搜索，寻找匹配项。
• 参数：一个正则表达式对象，或者具有 Symbol.search 方法的任意对象。如果 regexp 不是 RegExp 对象，并且不具有 Symbol.search 方法，则会使用 new RegExp(regexp) 将其隐式转换为 RegExp。
• 返回：如果匹配成功，则返回正则表达式在字符串中首次匹配的索引；否则，返回 -1。

regexp 的 g 标志对 search() 方法的结果没有影响，搜索总是以正则表达式的 lastIndex 为 0 进行。

const str = "hey JudE";
const re = /[A-Z]/;
const reDot = /[.]/;
console.log(str.search(re)); // 返回 4，这是第一个大写字母“J”的索引
console.log(str.search(reDot)); // 返回 -1，找不到点符号“.”

const str = "hey JudE";
const re = /[A-Z]/;
const reDot = /[.]/;
console.log(str.search(re)); // 返回 4，这是第一个大写字母“J”的索引
console.log(str.search(reDot)); // 返回 -1，找不到点符号“.”

String.prototype.slice() ​

slice(indexStart, indexEnd)

slice(indexStart, indexEnd)

• 描述：方法提取字符串的一部分，并将其作为新字符串返回，而不修改原始字符串。
• 参数：要返回的子字符串中包含的第一个字符的索引。（从第几位开始）
  1. indexStart >= str.length，则返回一个空字符串。
  2. indexStart < 0，则索引从字符串末尾开始计数。从 (indexStart + str.length, 0) 。
  3. indexStart 被省略、为 undefined，或无法转换为数字，则将其视为 0。
• [可选参数]：要返回的子字符串中排除的第一个字符的索引（到第几位）。(不包含结束位置)
  1. indexEnd 被省略、为 undefined，或无法转换为数字，或者 indexEnd >= str.length，则 slice() 提取到字符串的末尾。
  2. indexEnd < 0，则索引从字符串末尾开始计数。从 (indexStart + str.length, 0) 。
  3. 在标准化负值后，indexEnd <= indexStart（indexEnd 表示位于 indexStart 之前的字符），则返回一个空字符串。

const str1 = "The morning is upon us."; // str1 的长度是 23。
const str2 = str1.slice(1, 8); // he morn
const str3 = str1.slice(4, -2); // morning is upon u
const str4 = str1.slice(12); // is upon us.
const str5 = str1.slice(30); // ""
const str = str1.slice(12, -12)// ""，在标准化负值后 起始位置为12，结束位置为11，indexEnd <= indexStart

const str1 = "The morning is upon us."; // str1 的长度是 23。
const str2 = str1.slice(1, 8); // he morn
const str3 = str1.slice(4, -2); // morning is upon u
const str4 = str1.slice(12); // is upon us.
const str5 = str1.slice(30); // ""
const str = str1.slice(12, -12)// ""，在标准化负值后 起始位置为12，结束位置为11，indexEnd <= indexStart

String.prototype.substring() ​

substring(indexStart, indexEnd)

substring(indexStart, indexEnd)

• 描述：方法返回该字符串从起始索引到结束索引（不包括）的部分，如果未提供结束索引，则返回到字符串末尾的部分。
• 参数：返回子字符串中第一个要包含的字符的索引。
• [可选参数]：返回子字符串中第一个要排除的字符的索引。
  1. 如果省略了 indexEnd，则 substring() 提取字符直到字符串的末尾。(不包含结束位置)
  2. 如果 indexStart 等于 indexEnd，则 substring() 返回一个空字符串。
  3. 如果 indexStart 大于 indexEnd，则 substring() 的效果就像交换了这两个参数一样；
  4. 任何小于 0 或大于 str.length 的参数值都会被视为分别等于 0 和 str.length。
  5. 任何值为 NaN 的参数将被视为等于 0。

const anyString = "Mozilla"; // anyString.length = 7

console.log(anyString.substring(0, 1)); // 'M'
console.log(anyString.substring(1, 0)); // 'M'

console.log(anyString.substring(0, 6)); // 'Mozill'

console.log(anyString.substring(4)); // 'lla'
console.log(anyString.substring(4, 7)); // 'lla'
console.log(anyString.substring(7, 4)); // 'lla'

console.log(anyString.substring(0, 7)); // 'Mozilla'
console.log(anyString.substring(0, 10)); // 'Mozilla'


// 获取字符串的最后 4 个字符
console.log(text.substring(text.length - 4)); // 打印“illa”

// 获取字符串的最后 5 个字符
console.log(text.substring(text.length - 5)); // 打印“zilla”

const anyString = "Mozilla"; // anyString.length = 7

console.log(anyString.substring(0, 1)); // 'M'
console.log(anyString.substring(1, 0)); // 'M'

console.log(anyString.substring(0, 6)); // 'Mozill'

console.log(anyString.substring(4)); // 'lla'
console.log(anyString.substring(4, 7)); // 'lla'
console.log(anyString.substring(7, 4)); // 'lla'

console.log(anyString.substring(0, 7)); // 'Mozilla'
console.log(anyString.substring(0, 10)); // 'Mozilla'


// 获取字符串的最后 4 个字符
console.log(text.substring(text.length - 4)); // 打印“illa”

// 获取字符串的最后 5 个字符
console.log(text.substring(text.length - 5)); // 打印“zilla”

const text = "Mozilla";
// substring
console.log(text.substring(5, 2)); // "zil"
// slice
console.log(text.slice(5, 2)); // ""

const text = "Mozilla";
// substring
console.log(text.substring(5, 2)); // "zil"
// slice
console.log(text.slice(5, 2)); // ""

// substring
console.log(text.substring(-5, 2)); // "Mo"
console.log(text.substring(-5, -2)); // ""

// slice （从末尾开始反向计数）
console.log(text.slice(-5, 2)); // ""
console.log(text.slice(-5, -2)); // "zil"

// substring
console.log(text.substring(-5, 2)); // "Mo"
console.log(text.substring(-5, -2)); // ""

// slice （从末尾开始反向计数）
console.log(text.slice(-5, 2)); // ""
console.log(text.slice(-5, -2)); // "zil"

String.prototype.split() ​

split(separator, limit)

split(separator, limit)

• 描述：方法接受一个模式(也可以是正则)，通过搜索模式将字符串分割成一个有序的子串列表，将这些子串放入一个数组，并返回该数组。
• 参数：描述每个分割应该发生在哪里的模式。可以是 undefined，一个字符串，或者一个具有 Symbol.split 方法的对象——典型的例子是正则表达式。省略 separator 或传递 undefined 会导致 split() 返回一个只包含所调用字符串数组。所有不是 undefined 的值或不具有 Symbol.split 方法的对象都被强制转换为字符串。
• [可选参数]：一个非负整数，指定数组中包含的子字符串的数量限制。当提供此参数时，split 方法会在指定 separator 每次出现时分割该字符串，但在已经有 limit 个元素时停止分割。任何剩余的文本都不会包含在数组中。
  1. 如果在达到极限之前就达到了字符串的末端，那么数组包含的条目可能少于 limit。
  2. 如果 limit 为 0，则返回 []。
  3. limit>= str.length 或者 小于 0，则都返回完整的字符串分割数组。

let str = 'abc abc abc abc abc'
str.split(" ") // [abc,abc,abc,abc,abc]
str.split(" ",2) // [abc,abc]
str.split(" ",0) // [0]
str.split(" ",-1) // [abc,abc,abc,abc,abc]
str.split(" ",10) // [abc,abc,abc,abc,abc]

let str = 'abc abc abc abc abc'
str.split(" ") // [abc,abc,abc,abc,abc]
str.split(" ",2) // [abc,abc]
str.split(" ",0) // [0]
str.split(" ",-1) // [abc,abc,abc,abc,abc]
str.split(" ",10) // [abc,abc,abc,abc,abc]

String.prototype.toLowerCase() ​

• 描述：方法返回将字符串转换为小写形式后的值。不会影响字符串本身的值。

console.log("ALPHABET".toLowerCase()); // 'alphabet'

console.log("ALPHABET".toLowerCase()); // 'alphabet'

String.prototype.toUpperCase() ​

• 描述：方法返回将字符串转换为大写形式后的值。不会影响字符串本身的值。

console.log("alphabet".toUpperCase()); // 'ALPHABET'

console.log("alphabet".toUpperCase()); // 'ALPHABET'

String.prototype.toLocaleLowerCase() ​

• 描述：方法返回根据特定区域设置的大小写映射规则将字符串转换为小写形式的值。不会影响字符串本身的值。
• [可选参数]：一个带有 BCP 47 语言标签的字符串，或者是这种字符串的数组。指示要根据特定区域设置的大小写映射规则进行转换的区域设置。

"ALPHABET".toLocaleLowerCase(); // 'alphabet'
const locales = ["tr", "TR", "tr-TR", "tr-u-co-search", "tr-x-turkish"];
"\u0130".toLocaleLowerCase(locales) === "i"; // true

"ALPHABET".toLocaleLowerCase(); // 'alphabet'
const locales = ["tr", "TR", "tr-TR", "tr-u-co-search", "tr-x-turkish"];
"\u0130".toLocaleLowerCase(locales) === "i"; // true

String.prototype.toLocaleUpperCase() ​

• 描述：方法返回根据特定区域设置的大小写映射规则将字符串转换为大写形式的值。不会影响字符串本身的值。
• [可选参数]：一个带有 BCP 47 语言标签的字符串，或者是这种字符串的数组。指示要根据特定区域设置的大小写映射规则进行转换的区域设置。

"alphabet".toLocaleUpperCase(); // 'ALPHABET'
const locales = ["lt", "LT", "lt-LT", "lt-u-co-phonebk", "lt-x-lietuva"];
"i\u0307".toLocaleUpperCase(locales); // 'I'

"alphabet".toLocaleUpperCase(); // 'ALPHABET'
const locales = ["lt", "LT", "lt-LT", "lt-u-co-phonebk", "lt-x-lietuva"];
"i\u0307".toLocaleUpperCase(locales); // 'I'

String.prototype.trim() ​

• 描述：方法会从字符串的两端移除空白字符，并返回一个新的字符串，而不会修改原始字符串。

const str = "   foo  ";
console.log(str.trim()); // 'foo'

const str = "   foo  ";
console.log(str.trim()); // 'foo'

String.prototype.trimStart() ​

• 描述：方法会从字符串的两端移除空白字符，并返回一个新的字符串，而不会修改原始字符串。trimLeft() 是该方法的别名。

let str = "  foo  "; // 7
str = str.trimStart(); // 5
console.log(str); // 'foo  '

let str = "  foo  "; // 7
str = str.trimStart(); // 5
console.log(str); // 'foo  '

String.prototype.trimEnd() ​

• 描述：方法会从字符串的两端移除空白字符，并返回一个新的字符串，而不会修改原始字符串。trimRight() 是该方法的别名。

let str = "  foo  "; // 7
str = str.trimEnd();  // 5
console.log(str); // '   foo'

let str = "  foo  "; // 7
str = str.trimEnd();  // 5
console.log(str); // '   foo'

String.prototype.toString() ​

• 描述：
  1. String 对象重写了 Object 的 toString 方法；
  2. 它不会继承 Object.prototype.toString()。
  3. 对于 String 值，toString 方法返回字符串本身（如果它是原始值）或 String 对象封装的字符串。
  4. 它的实现与 String.prototype.valueOf() 完全相同。
  5. 当一个 String 对象在期望字符串的上下文中使用时（比如在模板字面量中），JavaScript 会自动调用 toString() 方法。
  6. String 原始值不会使用 toString() 方法来进行字符串强制转换——因为它们已经是字符串，所以不会进行转换。

const x = new String("Hello world");// x 是 字符对象
x.toString() // 字符串原始值

String.prototype.toString = () => "已经被重写了";
console.log(`${"foo"}`); // "foo"
console.log(`${new String("foo")}`); // "已经被重写了"

const x = new String("Hello world");// x 是 字符对象
x.toString() // 字符串原始值

String.prototype.toString = () => "已经被重写了";
console.log(`${"foo"}`); // "foo"
console.log(`${new String("foo")}`); // "已经被重写了"

String.prototype.valueOf() ​

• 描述：String 的 valueOf() 方法以字符串数据类型返回 String 对象的原始值。此值等价于 String.prototype.toString()。此方法通常由 JavaScript 在内部调用，而不是在代码中显式调用。

已弃用 ​

anchor ​

big ​

blink ​

bold ​

fixed ​

fontcolor ​

fontsize ​

small ​

strike ​

sub ​

substr ​

sup ​

italics ​

link --> ​