6.3 String 类型

JavaScript 中的 String 类型是一种表示文本数据的数据类型。字符串可以包含任何字符序列，例如字母、数字、符号和空格。String 类型在 JavaScript 中非常重要，因为它是处理文本数据的基本数据类型。在 Web 开发中，大量的文本数据都是以字符串的形式传递和操作的，因此了解和熟练掌握 String 类型的方法是非常重要的。在基本数据类型中也讲过，创建字符串的方法包括使用单引号、双引号或反引号来定义字符串文字，例如：

let str1 = 'Hello, world!';
let str2 = 'JavaScript is awesome!';
let str3 = `My name is ${name}.`;

在第三个示例中，我们使用反引号（也称为模板文字）来定义字符串，这允许我们插入变量或表达式的值。
还可以使用 String 函数创建，例如：
let str1 = String('Hello, world!';)
显然这种方式创建没有直接用单引号或者双引号创建的简洁。
下面就详细的讲解常用的属性和方法。

length 属性

在 JavaScript 中，可以使用 length 属性获取字符串的长度。这个属性返回一个表示字符串中字符数量的数字，包括空格和标点符号。
例如，对于下面的字符串：
const str = "Hello, World!";
可以使用 length 属性来获取它的长度：
`console.log(str.length); // 输出 13“
在这个例子中，字符串 str 的长度是 13，因为它包含了 13 个字符（包括空格和标点符号）。

indexOf 方法

indexOf() 方法用于查找一个子字符串在另一个字符串中第一次出现的位置。如果子字符串存在于原始字符串中，indexOf() 方法返回子字符串第一次出现的位置的索引；否则，返回 -1。
以下是 indexOf() 方法的函数签名：
str.indexOf(searchValue[, fromIndex])
这里，str 是要搜索的字符串，searchValue 是要查找的子字符串，fromIndex 是可选的起始搜索索引位置。如果省略 fromIndex 参数，则默认从字符串的开头开始搜索。如果指定了 fromIndex 参数，则 indexOf() 方法将从该位置开始搜索。以下是一个例子，演示如何使用 indexOf() 方法：

const str = 'Hello, World!';











const index = str.indexOf('World');
console.log(index); // 输出 7

在这个例子中，我们在字符串 str 中查找子字符串 “World”，并将返回的索引值存储在变量 index 中。由于子字符串 “World” 在字符串 str 中的第一个出现位置是索引 7，因此输出结果为 7。
如果要查找一个不存在的子字符串，indexOf() 方法将返回 -1：

const str = 'Hello, World!';











const index = str.indexOf('JavaScript');
console.log(index); // 输出 -1

在这个例子中，我们在字符串 str 中查找子字符串 “JavaScript”，但是该子字符串在字符串 str 中不存在，因此输出结果为 -1。

lastIndexOf 方法

lastIndexOf() 方法用于查找一个子字符串在另一个字符串中最后一次出现的位置。如果子字符串存在于原始字符串中，lastIndexOf() 方法返回子字符串最后一次出现的位置的索引；否则，返回 -1。以下是 lastIndexOf 方法的签名：
str.lastIndexOf(searchValue[, fromIndex])
这里，str 是要搜索的字符串，searchValue 是要查找的子字符串，fromIndex 是可选的起始搜索索引位置。如果省略 fromIndex 参数，则默认从字符串的末尾开始搜索。如果指定了 fromIndex 参数，则 lastIndexOf() 方法将从该位置开始向前搜索。
以下是一个例子，演示如何使用 lastIndexOf() 方法：

const str = 'Hello, World!';











const index = str.lastIndexOf('o');
console.log(index); // 输出 8

在这个例子中，我们在字符串 str 中查找字符 “o” 最后一次出现的位置，并将返回的索引值存储在变量 index 中。由于字符 “o” 最后一次出现的位置是索引 8，因此输出结果为 8。
如果要查找一个不存在的子字符串，lastIndexOf() 方法将返回 -1：

const str = 'Hello, World!';











const index = str.lastIndexOf('JavaScript');
console.log(index); // 输出 -1

在这个例子中，我们在字符串 str 中查找子字符串 “JavaScript”，但是该子字符串在字符串 str 中不存在，因此输出结果为 -1。

includes 方法

在 JavaScript 中，可以使用 includes() 方法来判断一个字符串是否包含另一个字符串。如果原始字符串包含指定的子字符串，includes() 方法将返回 true；否则，返回 false。以下是 includes 方法的函数签名：
str.includes(searchValue[, fromIndex])
这里，str 是要搜索的字符串，searchValue 是要查找的子字符串，fromIndex 是可选的起始搜索索引位置。如果省略 fromIndex 参数，则默认从字符串的开头开始搜索。如果指定了 fromIndex 参数，则 includes() 方法将从该位置开始搜索。
以下是一个例子，演示如何使用 includes() 方法：

const str = 'Hello, World!';











const isContained = str.includes('World');
console.log(isContained); // 输出 true

在这个例子中，我们在字符串 str 中查找子字符串 “World”，并将返回的布尔值存储在变量 isContained 中。由于子字符串 “World” 在字符串 str 中存在，因此输出结果为 true。
如果要查找一个不存在的子字符串，includes() 方法将返回 false：

const str = 'Hello, World!';











const isContained = str.includes('JavaScript');
console.log(isContained); // 输出 false

在这个例子中，我们在字符串 str 中查找子字符串 “JavaScript”，但是该子字符串在字符串 str 中不存在，因此输出结果为 false。

substring 方法

substring() 方法用于返回指定位置的子字符串，函数签名如下：
str.substring(indexStart[, indexEnd])
这里，str 是要操作的字符串，indexStart 是子字符串的起始位置，indexEnd 是可选的子字符串结束位置。如果省略 indexEnd 参数，则 substring() 方法将从 indexStart 位置开始一直提取到字符串的末尾。如果指定了 indexEnd 参数，则 substring() 方法将从 indexStart 位置开始提取字符串，一直提取到 indexEnd – 1 位置的字符。如果 indexStart 大于 indexEnd，则 substring() 方法会自动交换这两个参数的位置，以确保开始位置永远小于结束位置。
以下是一个例子，演示如何使用 substring() 方法：

const str = 'Hello, World!';











const subStr = str.substring(0, 5);
console.log(subStr); // 输出 "Hello"

在这个例子中，我们从字符串 str 的开始位置提取了从索引 0 到 4 的子字符串，并将其存储在变量 subStr 中。由于子字符串不包括结束位置的字符，因此输出结果为 “Hello”。
如果省略第二个参数，则 substring() 方法将从开始位置一直提取到字符串的末尾：

const str = 'Hello, World!';











const subStr = str.substring(7);
console.log(subStr); // 输出 "World!"

在这个例子中，我们从字符串 str 的开始位置提取了从索引 7 到字符串末尾的子字符串，并将其存储在变量 subStr 中。因为我们省略了第二个参数，所以 substring() 方法将从开始位置一直提取到字符串的末尾，输出结果为 “World!”。
需要注意的是，如果第一个参数大于第二个参数，则 substring() 方法会自动交换这两个参数的位置，以确保开始位置永远小于结束位置：

const str = 'Hello, World!';











const subStr = str.substring(5, 0);
console.log(subStr); // 输出 "Hello"

在这个例子中，我们从字符串 str 的开始位置提取了从索引 0 到 4 的子字符串，并将其存储在变量 subStr 中。但是我们错误地将开始位置设置为 5，结束位置设置为 0，substring() 方法会自动交换这两个参数的位置，确保开始位置永远小于结束位置。因此输出结果为 “Hello”。
在 substring() 方法中，如果传递了负数参数，则它们将被视为 0。
如果 beginIndex 是负数，则它将被解释为 0，例如：

const str = 'Hello, world!';















const subStr = str.substring(-6);
console.log(subStr); // 输出 "Hello, world!"

在这个例子中，我们传递了 -6 作为 substring() 方法的参数。由于这是一个负数，因此被视为 0。因此，输出结果为整个原始字符串。
如果 endIndex 是负数，则它也将被解释为 0，例如：

const str = 'Hello, world!';















const subStr = str.substring(0, -7);
console.log(subStr); // 输出 ""

在这个例子中，我们传递了 -7 作为 substring() 方法的第二个参数。由于这是一个负数，因此被视为 0。因此，substring() 方法会从字符串的第 0 个位置开始一直提取到最后。因此，输出结果为 “”空字符串。

slice 方法

slice() 方法用于从一个字符串中提取指定的子字符串。它的签名如下：
str.slice(beginIndex[, endIndex])
这里，str 是要操作的字符串，beginIndex 是子字符串的起始位置，endIndex 是可选的子字符串结束位置。如果省略 endIndex 参数，则 slice() 方法将从 beginIndex 位置开始一直提取到字符串的末尾。如果指定了 endIndex 参数，则 slice() 方法将从 beginIndex 位置开始提取字符串，一直提取到 endIndex – 1 位置的字符。如果 beginIndex 大于 endIndex，则 slice() 方法将返回一个空字符串。
以下是一个例子，演示如何使用 slice() 方法：

const str = 'Hello, World!';











const subStr = str.slice(0, 5);
console.log(subStr); // 输出 "Hello"

在这个例子中，我们从字符串 str 的开始位置提取了从索引 0 到 4 的子字符串，并将其存储在变量 subStr 中。由于子字符串不包括结束位置的字符，因此输出结果为 “Hello”。
如果省略第二个参数，则 slice() 方法将从开始位置一直提取到字符串的末尾：

const str = 'Hello, World!';











const subStr = str.slice(7);
console.log(subStr); // 输出 "World!"

在这个例子中，我们从字符串 str 的开始位置提取了从索引 7 到字符串末尾的子字符串，并将其存储在变量 subStr 中。因为我们省略了第二个参数，所以 slice() 方法将从开始位置一直提取到字符串的末尾，输出结果为 “World!”。
需要注意的是，与 substring() 方法不同，slice() 方法不会自动交换开始位置和结束位置的顺序，如果第一个参数大于第二个参数，则 slice() 方法将返回一个空字符串：

const str = 'Hello, World!';











const subStr = str.slice(5, 0);
console.log(subStr); // 输出 ""

在这个例子中，我们错误地将开始位置设置为 5，结束位置设置为 0，slice() 方法不会自动交换这两个参数的位置。因为开始位置大于结束位置，所以 slice() 方法将返回一个空字符串。
在 slice() 方法中，如果传递了负数参数，则它们将被视为相对于字符串末尾的位置。
如果 beginIndex 是负数，则它将被解释为从字符串末尾开始的偏移量，例如：

const str = 'Hello, world!';















const subStr = str.slice(-6);
console.log(subStr); // 输出 "world!"

在这个例子中，我们传递了 -6 作为 slice() 方法的参数，表示要从字符串的倒数第 6 个字符开始提取子字符串。因此，输出结果为 “world!”。
如果 endIndex 是负数，则它将被解释为从字符串末尾开始的偏移量，例如：

const str = 'Hello, world!';















const subStr = str.slice(0, -7);
console.log(subStr); // 输出 "Hello"

在这个例子中，我们传递了 -7 作为 slice() 方法的第二个参数，表示要从字符串的末尾开始，一直提取到倒数第 7 个字符（不包括该字符）。因此，输出结果为 “Hello”。
需要注意的是，如果 beginIndex 大于或等于字符串的长度，则 slice() 方法将返回一个空字符串。如果 endIndex 小于或等于 beginIndex，则 slice() 方法也将返回一个空字符串。

substr 方法

substr() 方法用于从字符串中提取指定长度的子字符串。它的函数签名如下：
str.substr(startIndex, length)
其中：

• 1 str：要提取子字符串的字符串。
• 2 startIndex：一个整数，表示从哪个位置开始提取子字符串。如果该参数为负数，则从字符串末尾开始计算位置。如果省略该参数，则从字符串的第一个字符开始提取。
• 3 length：一个整数，表示要提取的子字符串的长度。如果省略该参数，则从 startIndex 指定的位置到字符串末尾的所有字符都会被提取。
  以下是一个使用 substr() 方法的例子：

const str = 'Hello, world!';















const subStr1 = str.substr(7); // "world!"
const subStr2 = str.substr(0, 5); // "Hello"

在第一个 substr() 调用中，我们只传递了一个参数 7，表示从第 7 个字符开始提取子字符串。因为我们没有传递第二个参数，所以将提取从第 7 个字符到字符串末尾的所有字符，即 “world!”。
在第二个 substr() 调用中，我们传递了两个参数：0 和 5，分别表示要从字符串的第 0 个字符开始提取，提取 5 个字符。因此，substr() 方法返回从字符串的第 0 个字符开始的 5 个字符，即 “Hello”。
注意，与 substring() 方法不同，substr() 方法允许您传递负数作为 startIndex 参数，从而使其从字符串的末尾开始计算位置。
以下是一个例子：

const str = 'Hello, world!';















const subStr = str.substr(-6); // "world!"
console.log(subStr);

在这个例子中，我们传递了 -6 作为 substr() 方法的参数。因为该参数为负数，所以被解释为从字符串末尾倒数第 6 个字符开始提取。因此，substr() 方法返回从字符串的倒数第 6 个字符开始的所有字符，即 “world!”。
如果将负数传递给 substr() 方法的 length 参数，则会将其视为 0，即不提取任何字符。例如：

const str = 'Hello, world!';















const subStr = str.substr(7, -2); // ""
console.log(subStr);

在这个例子中，我们传递了 -2 作为 substr() 方法的第二个参数。因为该参数为负数，所以被解释为不提取任何字符。因此，substr() 方法返回空字符串 “”。
substr() 方法在 ECMAScript 2015 标准中已被标记为不推荐使用（deprecated）。虽然该方法仍然有效，但是为了编写更具可读性和可维护性的代码，建议使用 substring() 或 slice() 方法来代替 substr()。
原因是 substr() 方法存在一些不利的特性，比如对于负数参数的处理不如 substring() 和 slice() 明确，以及不同浏览器在处理负数参数时可能会有不同的行为，这可能导致代码的可移植性问题。

trim 方法

trim() 方法用于去除字符串两端的空格（包括空格、制表符、换行符等空白字符），并返回去除空格后的新字符串，它没有参数。
下面是一个例子：

const str = '   hello, world!   ';
const trimmedStr = str.trim();

console.log(trimmedStr); // "hello, world!"

在这个例子中，我们调用了 trim() 方法来去除字符串 str 两端的空格。trim() 方法返回去除空格后的新字符串，即 “hello, world!”。
需要注意的是，trim() 方法不会改变原始字符串本身，而是返回一个新的字符串。此外，如果字符串本身没有空格，那么 trim() 方法也不会对字符串做出任何修改，直接返回原始字符串。例如：

const str = 'hello, world!';



const trimmedStr = str.trim();

console.log(trimmedStr); // "hello, world!"

在这个例子中，字符串 str 本身没有任何空格，因此调用 trim() 方法不会对字符串做出任何修改，直接返回原始字符串 hello, world!。
还需要注意的是，trim() 方法只能去除字符串两端的空格，不能去除字符串中间的空格。

split 方法

split() 方法用于将字符串按照指定的分隔符分割成一个数组。split() 方法接受一个参数，即分隔符字符串或正则表达式，返回一个数组，它的函数签名如下：
str.split(separator, limit)
其中：

• 1 str：要进行分割的字符串。
• 2 separator：可选，指定分隔符。可以是一个字符串或正则表达式。如果省略此参数，则使用默认的分隔符，即空白字符（空格、制表符、换行符等）。
• 3 limit：可选，指定返回数组的最大长度。如果省略此参数，则不限制数组的长度。
  下面是一个例子：

const str = 'apple,banana,orange';
const arr = str.split(',');
console.log(arr); // ["apple", "banana", "orange"]

在这个例子中，我们调用了 split() 方法，将字符串 str 按照逗号分隔符 , 分割成一个数组。split() 方法返回一个新数组 [“apple”, “banana”, “orange”]，其中每个元素都是原始字符串中分隔符分隔后的子字符串。
如果省略 split() 方法的参数，将使用默认的分隔符，即空格字符、制表符、换行符等空白字符。例如：

const str = 'apple banana orange';
const arr = str.split();
console.log(arr); // ["apple", "banana", "orange"]

在这个例子中，我们省略了 split() 方法的参数，使用默认的分隔符将字符串 str 分割成一个数组。split() 方法返回一个新数组 [“apple”, “banana”, “orange”]，其中每个元素都是原始字符串中默认分隔符分隔后的子字符串。
需要注意的是，如果分隔符参数是一个空字符串 “”，则 split() 方法将把字符串中的每个字符都分割成一个元素。例如：

const str = 'hello';
const arr = str.split('');
console.log(arr); // ["h", "e", "l", "l", "o"]

在这个例子中，我们使用空字符串 “” 作为分隔符将字符串 str 分割成一个数组。split() 方法返回一个新数组 [“h”, “e”, “l”, “l”, “o”]，其中每个元素都是原始字符串中的一个字符。
最后，需要注意的是，split() 方法不会修改原始字符串本身，而是返回一个新的数组。参数是正则表达式的情况会在正则表达式章节讲解。

toUpperCase

toUpperCase()用于将字符串中的所有字母字符转换为大写形式。
具体来说，toUpperCase() 方法会将字符串中的所有小写字母字符都转换为相应的大写形式，并保留字符串中的所有非字母字符不变。
下面是一个例子：

const str = 'Hello, world!';















const upperStr = str.toUpperCase();
console.log(upperStr); // 输出 "HELLO, WORLD!"

在上面的例子中，toUpperCase() 方法将字符串 str 中的所有小写字母字符都转换为相应的大写形式，并将结果存储到变量 upperStr 中。
需要注意的是，toUpperCase() 方法不会修改原始字符串本身，而是返回一个新的字符串。另外，对于非字母字符，toUpperCase() 方法并不会将其转换为大写形式，而是保留其原始形式。

toLowerCase

toLowerCase()用于将字符串中的所有字母字符转换为小写形式。
具体来说，toLowerCase() 方法会将字符串中的所有大写字母字符都转换为相应的小写形式，并保留字符串中的所有非字母字符不变。
下面是一个例子：

const str = 'Hello, world!';















const lowerStr = str.toLowerCase();
console.log(lowerStr); // 输出 "hello, world!"

在上面的例子中，toLowerCase() 方法将字符串 str 中的所有大写字母字符都转换为相应的小写形式，并将结果存储到变量 lowerStr 中。
需要注意的是，toLowerCase() 方法不会修改原始字符串本身，而是返回一个新的字符串。另外，对于非字母字符，toLowerCase() 方法并不会将其转换为小写形式，而是保留其原始形式。

startsWith

startsWith()用于检查一个字符串是否以指定的子串开始。
startsWith() 方法的函数签名如下：
str.startsWith(searchString[, position])
其中：

• 1 str：要检查的字符串。
• 2 searchString：要查找的子串。
• 3 position：可选参数，表示从哪个索引位置开始查找子串。默认值为 0。
  startsWith() 方法返回一个布尔值，表示指定字符串是否以指定的子串开始。如果是，则返回 true，否则返回 false。
  下面是一个例子：

const str = 'Hello, world!';















console.log(str.startsWith('Hello')); // 输出 true
console.log(str.startsWith('World')); // 输出 false

在上面的例子中，startsWith() 方法被用来检查字符串 str 是否以子串 ‘Hello’ 开始。
如果要从字符串的指定位置开始查找子串，可以传递第二个参数 position。例如：

const str = 'Hello, world!';















console.log(str.startsWith('world', 7)); // 输出 true

在上面的例子中，startsWith() 方法被用来检查字符串 str 是否从索引位置 7 开始以子串 ‘world’ 开始。因为字符串中的第 7 个字符是小写字母 ‘w’，所以结果为 true。
需要注意的是，startsWith() 方法只检查字符串的开头是否匹配指定的子串，不会检查字符串中的其他位置。如果要检查字符串中是否包含指定的子串，可以使用 indexOf() 或 includes() 方法。

endsWith

endsWith() 方法是 JavaScript 字符串对象的一个原生方法，它用于检查一个字符串是否以指定的子串结尾。
endsWith() 方法的函数签名如下：
str.endsWith(searchString[, position])
其中：

• 1 str：要检查的字符串。
• 2 searchString：要查找的子串。
• 3 position：可选参数，表示从哪个索引位置开始查找子串。默认值为字符串的长度。
  endsWith() 方法返回一个布尔值，表示指定字符串是否以指定的子串结尾。如果是，则返回 true，否则返回 false。
  下面是一个例子：

const str = 'Hello, world!';















console.log(str.endsWith('world!')); // 输出 true
console.log(str.endsWith('hello')); // 输出 false

在上面的例子中，endsWith() 方法被用来检查字符串 str 是否以子串 ‘world!’ 结尾。
如果要从字符串的指定位置开始查找子串，可以传递第二个参数 position。例如：

const str = 'Hello, world!';















console.log(str.endsWith('Hello', 5)); // 输出 true

在上面的例子中，endsWith() 方法被用来检查字符串 str 是否从索引位置 5 开始以子串 ‘Hello’ 结尾。因为字符串中的前 5 个字符是 ‘Hello’，所以结果为 true。
需要注意的是，endsWith() 方法只检查字符串的结尾是否匹配指定的子串，不会检查字符串中的其他位置。如果要检查字符串中是否包含指定的子串，可以使用 indexOf() 或 includes() 方法。

replace 方法

replace()方法用于替换字符串中的子串。该方法的函数签名如下：
str.replace(regexp|substr, newSubStr|function)
其中：

• 1 str：要进行替换操作的字符串。
• 2 regexp|substr：用于匹配子串的正则表达式或字符串。如果该参数是字符串，则只会替换第一个匹配的子串。参数是正则表达式的情况会在正则表达式章节继续讲解。
• 3 newSubStr|function：替换匹配子串的新字符串或者一个用于创建新子串的函数。如果使用函数作为该参数，则该函数会被调用一次匹配到一个子串，该函数的参数包括匹配到的子串、该子串在原始字符串中的位置和原始字符串本身，该函数必须返回一个新的字符串。
  注意，该方法并不会改变原始字符串，而是返回一个新的字符串。示例：

let str = 'I like JavaScript. JavaScript is my favorite programming language.';

let newStr = str.replace('JavaScript', 'Python');
console.log(newStr);
// 输出："I like Python. JavaScript is my favorite programming language."

在这个例子中，我们使用 replace()方法将字符串中的第一个”JavaScript”替换为”Python”。该方法返回一个新的字符串，其中替换后的子串被替换成了新的字符串。

let str = 'I like JavaScript. JavaScript is my favorite programming language.';

let newStr = str.replace(/JavaScript/g, 'Python');

console.log(newStr);
// 输出："I like Python. Python is my favorite programming language."

在这个例子中，我们使用正则表达式作为第一个参数，将所有的”JavaScript”子串替换为”Python”。正则表达式/JavaScript/g 中的”g”表示全局匹配，即替换所有匹配的子串。还是使用正则表达式可以更灵活的匹配和替换子串，在后边讲解正则表达式的章节再详细的讲解 replace 方法配合正则表达式的使用方法。

find 方法

find()方法用于在字符串中查找指定的子串，并返回找到的第一个子串。
find() 的函数签名如下：
str.find(substring)
其中：

• 1 str：要查找的字符串。
• 2 substring：一个字符串，用于指定要查找的子串。
  find() 方法会在字符串中查找第一个与 substring 相同的子串，如果找到，则返回该子串；如果找不到，则返回 undefined。需要注意的是，find() 方法区分大小写。
  下面是一个例子：

const str = 'hello, world!';



console.log(str.find('world')); // 输出 "world"
console.log(str.find('World')); // 输出 undefined

在上面的例子中，find() 方法被用来在字符串 str 中查找子串 ‘world’。因为 ‘world’ 出现在字符串的第 7 个位置（从 0 开始数），所以返回 “world”。而当查找 ‘World’ 时，由于大小写不匹配，返回 undefined。
需要注意的是，find() 方法是 ES6 引入的新方法，如果在老版本的 JavaScript 中使用，需要先进行兼容性检测。

indexOf 方法

indexOf() 方法用于查找指定字符串在当前字符串中第一次出现的位置。如果当前字符串中没有找到指定字符串，则返回 -1。
indexOf() 方法的函数签名如下：
str.indexOf(searchValue, fromIndex)
其中：

• 1 searchValue：要查找的字符串。
• 2 fromIndex：开始查找的位置。默认为 0，如果该参数为负数，则认为是 0，从字符串的开头开始搜索。
  下面是一个例子：

const str = 'Hello, world!';















console.log(str.indexOf('world')); // 输出 7
console.log(str.indexOf('l')); // 输出 2
console.log(str.indexOf('p')); // 输出 -1
console.log(str.indexOf('o', 5)); // 输出 8
console.log(str.indexOf('o', -6)); // 输出 4

在上面的例子中，我们定义了一个字符串 str，然后使用 indexOf() 方法查找字符串 “world”、字符 “l”、字符 “p” 在字符串 str 中第一次出现的位置。由于字符串 str 中不包含字符串 “p”，因此返回 -1。
另外，我们还可以使用 fromIndex 参数指定开始查找的位置。例如，再倒数第二个例子中，我们指定了从 index 是 5 的位置开始查找，所以找到的是 index 为 8 的 o，而不是 index 是 4 的 o。最后一个例子中，演示了当 startIndex 参数是负数时，会从第 0 个开始查找。
需要注意的是，indexOf() 方法区分大小写。如果要忽略大小写进行查找，可以将字符串转换为小写或大写，然后再进行查找，例如：

const str = 'Hello, world!';















console.log(str.indexOf('WORLD')); // 输出 -1
console.log(str.toLowerCase().indexOf('WORLD'.toLowerCase())); // 输出 7

lastIndexOf 方法

lastIndexOf() 方法用于查找字符串中最后一次出现指定字符或子串的位置。
该方法的语法如下：
str.lastIndexOf(searchValue[, fromIndex])
其中，searchValue 参数是要查找的子串，fromIndex 参数是从字符串的哪个索引位置开始反向搜索（可选，默认为字符串的末尾索引）。
lastIndexOf() 方法从字符串的末尾开始反向搜索，查找最后一次出现指定字符或子串的位置。如果找到了匹配的子串，则返回该子串在字符串中最后一次出现的位置索引；如果未找到，则返回 -1。
以下是一些示例：

const str = 'hello world';
console.log(str.lastIndexOf('l')); // 输出 9，最后一个 "l" 的位置
console.log(str.lastIndexOf('o')); // 输出 7，最后一个 "o" 的位置
console.log(str.lastIndexOf('l', 8)); // 输出 3，从索引 8 开始向前搜索，找到的最后一个 "l" 的位置
console.log(str.lastIndexOf('x')); // 输出 -1，未找到

需要注意的是，lastIndexOf() 方法的 fromIndex 参数是从字符串末尾开始计算的，而不是从字符串开头。如果 fromIndex 参数大于或等于字符串的长度，则 lastIndexOf() 方法将从字符串的末尾开始搜索，等价于不传入 fromIndex 参数。如果 fromIndex 参数是负数，则认为是 0，而从 0 开始反向搜索相当于是从空字符串中进行搜索，肯定只有搜索空字符串时，返回 0，搜索其他子串时返回值是 0。

includes 方法

includes()方法是用于检查字符串中是否包含指定的子字符串，如果包含则返回 true，否则返回 false。includes 方法的函数签名如下：
str.includes(searchString[, position])
其中，str 表示要搜索的字符串，searchString 表示要查找的子字符串，position 是可选的，表示从哪个位置开始搜索。如果不指定 position，则默认从字符串的开头开始搜索。如果 position 是负数，则从字符串末尾的偏移量开始的位置搜索。如果 position 的绝对值大于字符串的长度，则整个字符串都不会被搜索。如果 position 为 0 或正数，则从指定位置开始向字符串结尾的方向搜索。
例如：

const str = 'Hello, world!';















console.log(str.includes('world', 8)); // 输出 false
console.log(str.includes('world', 6)); // 输出 true
console.log(str.includes('world', -6)); // true，从字符串 "Hello " 后的位置开始搜索

上面的代码中，第一个 includes()调用将从字符串的第 8 个字符开始搜索子字符串，但由于子字符串不在该位置，因此返回 false。第二个 includes()调用从字符串的第 6 个字符开始搜索子字符串，并找到了该子字符串，因此返回 true。第三个的参数为-6 表示从字符串末尾开始，往前数第 6 个字符处，也就是空格字符处，作为搜索的起点。
includes()方法是 ES6 中新增的方法，因此不是所有浏览器都支持它。在使用时要注意浏览器兼容性问题。

charAt 方法

charAt() 是 JavaScript 字符串的一个实例方法，用于返回指定位置的字符。它接受一个参数 index，表示要返回的字符的位置。如果指定的位置超出了字符串的长度，charAt() 返回一个空字符串 ”。
charAt() 方法的函数签名如下：
str.charAt(index)
其中：

• 1 str：要返回字符的字符串。
• 2 index：要返回的字符在字符串中的位置。
  下面是一个例子：

const str = 'hello, world!';



console.log(str.charAt(1)); // 输出 'e'
console.log(str.charAt(100)); // 输出 ''

在上面的例子中，charAt() 方法被用来返回字符串 str 中的第二个字符 ‘e’ 和第 100 个字符（即不存在的字符），结果返回一个空字符串 ”。

charCodeAt 方法

charCodeAt() 是 JavaScript 字符串的一个实例方法，用于返回指定位置字符的 Unicode 编码值。它接受一个参数 index，表示要返回的字符的位置。如果指定的位置超出了字符串的长度，charCodeAt() 返回 NaN。
charCodeAt() 方法的函数签名如下：
str.charCodeAt(index)
其中：

• 1 str：要返回字符编码值的字符串。
• 2 index：要返回字符的位置。
  下面是一个例子：

const str = 'hello, world!';



console.log(str.charCodeAt(1)); // 输出 101
console.log(str.charCodeAt(100)); // 输出 NaN

在上面的例子中，charCodeAt() 方法被用来返回字符串 str 中的第二个字符 ‘e’ 的 Unicode 编码值 101 和第 100 个字符（即不存在的字符），结果返回 NaN。
最后再介绍一个可能会用到的静态方法

String.fromCharCode

String.fromCharCode() 是一个静态方法，它接收一或多个 Unicode 码点（code point）作为参数，并返回一个字符串。
代码示例：

String.fromCharCode(65); // "A"
String.fromCharCode(72, 69, 76, 76, 79); // "HELLO"

第一个示例中，传入的参数是单个码点 65，表示大写字母 A 的码点，返回字符串 “A”。
第二个示例中，传入的参数是多个码点，分别代表大写字母 H、