JavaScript 字符串操作常用方法详解

1. 获取字符串长度

在 JavaScript 中，字符串对象提供了一个 length 属性，利用该属性即可获取字符串的字符数量。

const str = 'hello';
str.length   // 输出结果：5

2. 获取字符串指定位置的值

使用 charAt() 和 charCodeAt() 方法，可以通过索引值提取字符串中特定位置的字符信息。

• charAt() 方法返回指定索引处的字符本身。
• charCodeAt() 方法则返回该位置字符对应的 Unicode 编码值。

（1）charAt()

该方法用于返回字符串中指定索引位置的字符，其基本语法如下：

string.charAt(index)

其中 index 代表目标字符在字符串中的索引位置。

const str = 'hello';
str.charAt(1)  // 输出结果：e 

既然字符串支持通过索引直接访问字符，那么 str[index] 与 charAt() 有何区别？

const str = 'hello';
str.charAt(1)  // 输出结果：e 
str[1]         // 输出结果：e 
str.charAt(5)  // 输出结果：'' 
str[5]         // 输出结果：undefined

当索引超出字符串长度范围时，str[index] 会返回 undefined，而 charAt(index) 返回空字符串；此外，str[index] 在 IE6 至 IE8 浏览器中不兼容，charAt(index) 则具备更好的兼容性。

（2）charCodeAt()

charCodeAt()：该方法返回指定索引处字符的 Unicode 编码值，结果为 0 到 65535 之间的整数，代表该位置的 UTF-16 代码单元；若索引处无字符，则返回 NaN。

let str = "abcdefg";
console.log(str.charCodeAt(1)); // "b" --> 98

利用此方法可筛选特定 Unicode 范围内的字符。例如，数字 0 至 9 的 Unicode 编码范围为 48 至 57，借此可过滤字符串中的数字；若熟悉正则表达式，使用正则处理会更为便捷。

3. 检索字符串是否包含特定序列

以下五种方法均可用于检测字符串中是否包含指定序列。前两种方法返回匹配项的索引值，且仅返回首次匹配的位置；后三种方法返回布尔值，指示是否找到匹配内容。

注意：这 5 个方法均区分大小写。

（1）indexOf()

indexOf()：用于查找指定字符，若存在则返回首次匹配的位置索引，否则返回 -1，其语法如下：

string.indexOf(searchvalue,fromindex)

该方法包含两个参数：

• searchvalue：必需参数，指定需要检索的字符串值。
• fromindex：可选整数参数，指定开始检索的起始位置，合法取值范围为 0 到 string.length - 1。若省略此参数，则从字符串起始位置开始检索。

let str = "abcdefgabc";
console.log(str.indexOf("a"));   // 输出结果：0
console.log(str.indexOf("z"));   // 输出结果：-1
console.log(str.indexOf("c", 4)) // 输出结果：9

（2）lastIndexOf()

lastIndexOf()：用于查找指定字符，若存在则返回最后一次匹配的位置索引，否则返回 -1。

let str = "abcabc";
console.log(str.lastIndexOf("a"));  // 输出结果：3
console.log(str.lastIndexOf("z"));  // 输出结果：-1

该方法与 indexOf() 类似，区别在于查找方向：indexOf() 为正序查找，而 lastIndexOf() 为逆序查找。

（3）includes()

includes()：用于判断字符串是否包含指定的子字符串。若找到匹配项则返回 true，否则返回 false。其语法如下：

string.includes(searchvalue, start)

该方法包含两个参数：

• searchvalue：必需参数，指定要查找的字符串。
• start：可选参数，指定开始查找的位置，默认为 0。

let str = 'Hello world!';

str.includes('o')  // 输出结果：true
str.includes('z')  // 输出结果：false
str.includes('e', 2)  // 输出结果：false

（4）startsWith()

startsWith()：用于检测字符串是否以指定的子字符串开头。若以指定子字符串开头则返回 true，否则返回 false。其语法与 includes() 方法相同。

let str = 'Hello world!';

str.startsWith('Hello') // 输出结果：true
str.startsWith('Helle') // 输出结果：false
str.startsWith('wo', 6) // 输出结果：true

（5）endsWith()

endsWith()：用于判断当前字符串是否以指定的子字符串结尾。若指定子字符串位于搜索字符串末尾则返回 true，否则返回 false。其语法如下：

string.endsWith(searchvalue, length)

该方法包含两个参数：

• searchvalue：必需参数，指定要搜索的子字符串。
• length：可选参数，指定用于比较的字符串长度，默认值为原始字符串长度 string.length。

let str = 'Hello world!';

str.endsWith('!')       // 输出结果：true
str.endsWith('llo')     // 输出结果：false
str.endsWith('llo', 5)  // 输出结果：true

当第二个参数设置为 5 时，方法仅从前 5 个字符中进行检索，因此返回 true。

4. 连接多个字符串

concat() 方法用于将两个或多个字符串连接成一个新字符串。该方法不修改原字符串，而是返回连接后的新字符串。其语法如下：

string.concat(string1, string2, ..., stringX)

参数 string1, string2, ..., stringX 为必需参数，表示将被连接为一个字符串的一个或多个字符串对象。

let str = "abc";
console.log(str.concat("efg"));          //输出结果："abcefg"
console.log(str.concat("efg","hijk")); //输出结果："abcefghijk"

虽然 concat() 是专门用于拼接字符串的方法，但在实际开发中，更常使用加号操作符 +，因其语法更为简洁。

5. 字符串分割成数组

split() 方法用于将字符串分割为字符串数组。该方法不修改原始字符串。其语法如下：

string.split(separator,limit)

该方法包含两个参数：

• separator：必需参数，可以是字符串或正则表达式，指定分割字符串的位置。
• limit：可选参数，指定返回数组的最大长度。若设置此参数，返回的子串数量不会超过该值；若未设置，则分割整个字符串，不受长度限制。

let str = "abcdef";
str.split("c");    // 输出结果：["ab", "def"]
str.split("", 4)   // 输出结果：['a', 'b', 'c', 'd'] 

若将空字符串用作 separator，则字符串中的每个字符之间都会被分割。

str.split("");     // 输出结果：["a", "b", "c", "d", "e", "f"]

在将字符串分割为数组时，可通过正则表达式同时使用多个分隔符进行拆分。

const list = "apples,bananas;cherries"
const fruits = list.split(/[,;]/)
console.log(fruits);  // 输出结果：["apples", "bananas", "cherries"]

6. 截取字符串

substr()、substring() 和 slice() 方法均可用于截取字符串。

（1） slice()

slice() 方法用于提取字符串的指定部分，并返回包含被提取部分的新字符串。其语法如下：

string.slice(start,end)

该方法包含两个参数：

• start：必需参数，指定截取片段的起始下标，第一个字符位置为 0。若为负数，则表示从字符串尾部开始计算。
• end：可选参数，指定截取片段的结束下标。若省略此参数，则提取从 start 到原字符串结尾的子串。若该参数为负数，则表示从字符串尾部开始计算的位置。

如前所述，若 start 为负数，则表示从字符串尾部开始计算的位置。例如，-1 指最后一个字符，-2 指倒数第二个字符，依此类推：

let str = "abcdefg";
str.slice(1,6);   // 输出结果："bcdef" 
str.slice(1);     // 输出结果："bcdefg" 
str.slice();      // 输出结果："abcdefg" 
str.slice(-2);    // 输出结果："fg"
str.slice(6, 1);  // 输出结果：""

注意，该方法返回的子串包含起始位置的字符，但不包含结束位置的字符。

（2） substr()

substr() 方法用于从字符串的开始下标起抽取指定数目的字符。其语法如下：

string.substr(start,length)

该方法包含两个参数：

• start：必需参数，指定抽取子串的起始下标，必须为数值。若为负数，则表示从字符串尾部开始计算的位置。例如，-1 指最后一个字符，-2 指倒数第二个字符，依此类推。
• length：可选参数，指定子串中的字符数，必须为数值。若省略此参数，则返回从 stringObject 起始位置到结尾的子串。

let str = "abcdefg";
str.substr(1,6); // 输出结果："bcdefg" 
str.substr(1);   // 输出结果："bcdefg" 相当于截取[1,str.length-1]
str.substr();    // 输出结果："abcdefg" 相当于截取[0,str.length-1]
str.substr(-1);  // 输出结果："g"

（3） substring()

substring() 方法用于提取字符串中两个指定下标之间的字符。其语法如下：

string.substring(from, to)

该方法包含两个参数：

• from：必需参数，指定提取子串的第一个字符在 string 中的位置，必须为非负整数。
• to：可选参数，指定提取子串的最后一个字符在 string 中的位置加 1。若省略此参数，则返回从起始位置到字符串结尾的子串。

注意：若参数 from 和 to 相等，则返回空字符串（长度为 0）。若 from 大于 to，则在提取前会交换这两个参数。此外，该方法不接受负数参数，若传入负数，则直接返回原字符串。

let str = "abcdefg";
str.substring(1,6); // 输出结果："bcdef" [1,6)
str.substring(1);   // 输出结果："bcdefg" [1,str.length-1]
str.substring();    // 输出结果："abcdefg" [0,str.length-1]
str.substring(6,1); // 输出结果 "bcdef" [1,6)
str.substring(-1);  // 输出结果："abcdefg"

注意，该方法返回的子串包含起始位置的字符，但不包含结束位置的字符。

7. 字符串大小写转换

toLowerCase() 和 toUpperCase() 方法可用于字符串的大小写转换。

（1）toLowerCase()

toLowerCase()：该方法用于将字符串转换为小写形式。

let str = "adABDndj";
str.toLowerCase(); // 输出结果："adabdndj"

（2）toUpperCase()

toUpperCase()：该方法用于将字符串转换为大写形式。

let str = "adABDndj";
str.toUpperCase(); // 输出结果："ADABDNDJ"

可利用此方法将字符串的首字母转换为大写：

let word = 'apple'
word = word[0].toUpperCase() + word.substr(1)
console.log(word) // 输出结果："Apple"

8. 字符串模式匹配

replace()、match() 和 search() 方法可用于匹配或替换字符串中的字符。

（1）replace()

replace()：该方法用于在字符串中用一些字符替换另一些字符，或替换与正则表达式匹配的子串。其语法如下：

string.replace(searchvalue, newvalue)

该方法包含两个参数：

• searchvalue：必需参数，指定子字符串或要替换模式的 RegExp 对象。若该值为字符串，则将其作为直接量文本模式进行检索，而非先转换为 RegExp 对象。
• newvalue：必需参数，指定替换文本或生成替换文本的函数。

let str = "abcdef";
str.replace("c", "z") // 输出结果：abzdef

执行全局替换并忽略大小写：

let str="Mr Blue has a blue house and a blue car";
str.replace(/blue/gi, "red");    // 输出结果：'Mr red has a red house and a red car'

注意：若 regexp 具有全局标志 g，则 replace() 方法将替换所有匹配的子串；否则，仅替换第一个匹配子串。

（2）match()

match()：该方法用于在字符串内检索指定值，或找到一个或多个正则表达式的匹配。该方法类似于 indexOf() 和 lastIndexOf()，但返回的是匹配值而非字符串位置。其语法如下：

string.match(regexp)

该方法的参数 regexp 为必需参数，指定要匹配模式的 RegExp 对象。若该参数不是 RegExp 对象，则需先将其传递给 RegExp 构造函数，转换为 RegExp 对象。

注意：该方法返回存放匹配结果的数组。数组内容取决于 regexp 是否具有全局标志 g。

let str = "abcdef";
console.log(str.match("c")) // ["c", index: 2, input: "abcdef", groups: undefined]

（3）search()

search()方法用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串。其语法如下：

string.search(searchvalue)

该方法的参数 regex 可以是需在 string 中检索的子串，也可以是需检索的 RegExp 对象。

注意：要执行忽略大小写的检索，请追加标志 i。该方法不执行全局匹配，将忽略标志 g，即仅返回第一次匹配成功的结果。若未找到任何匹配子串，则返回 -1。

返回值：返回 str 中第一个与 regexp 相匹配的子串的起始位置。

let str = "abcdef";
str.search(/bcd/)   // 输出结果：1

9. 移除字符串收尾空白符

trim()、trimStart() 和 trimEnd() 这三个方法可用于移除字符串首尾的空白符，空白符包括空格、制表符 tab、换行符等其他空白字符。

（1）trim()

trim() 方法用于移除字符串首尾的空白符，该方法不修改原始字符串：

let str = "  abcdef  "
str.trim()    // 输出结果："abcdef"

注意，该方法不适用于 null、undefined 或 Number 类型。

（2）trimStart()

trimStart() 方法的行为与 trim() 一致，但会返回一个从原始字符串开头删除了空白的新字符串，不修改原始字符串：

const s = '  abc  ';

s.trimStart()   // "abc  "

（3）trimEnd()

trimEnd() 方法的行为与 trim() 一致，但会返回一个从原始字符串结尾删除了空白的新字符串，不修改原始字符串：

const s = '  abc  ';

s.trimEnd()   // "  abc"

10. 获取字符串本身

valueOf() 和 toString() 方法均返回字符串本身的值，通常认为其实际用途有限。

（1）valueOf()

valueOf()：返回某个字符串对象的原始值，该方法通常由 JavaScript 自动调用，而非在代码中显式调用。

let str = "abcdef"
console.log(str.valueOf()) // "abcdef"

（2）toString()

toString()：返回字符串对象本身。

let str = "abcdef"
console.log(str.toString()) // "abcdef"

11. 重复一个字符串

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

'x'.repeat(3)     // 输出结果："xxx"
'hello'.repeat(2) // 输出结果："hellohello"
'na'.repeat(0)    // 输出结果：""

若参数为小数，则向下取整：

'na'.repeat(2.9) // 输出结果："nana"

若参数为负数或 Infinity，则报错：

'na'.repeat(Infinity)   // RangeError
'na'.repeat(-1)         // RangeError

若参数为 0 到 -1 之间的小数，则等同于 0，这是因为会先进行取整运算。0 到 -1 之间的小数取整后等于 -0，repeat 视同为 0。

'na'.repeat(-0.9)   // 输出结果：""

若参数为 NaN，则等同于 0：

'na'.repeat(NaN)    // 输出结果：""

若 repeat 的参数为字符串，则会先将其转换为数字。

'na'.repeat('na')   // 输出结果：""
'na'.repeat('3')    // 输出结果："nanana"

12. 补齐字符串长度

padStart() 和 padEnd() 方法用于补齐字符串的长度。若字符串长度不足指定值，则会在头部或尾部补全。

（1）padStart()

padStart()用于头部补全。该方法包含两个参数，第一个参数为数字，表示字符串补全后的长度；第二个参数为用于补全的字符串。

若原字符串长度等于或大于指定的最小长度，则返回原字符串：

'x'.padStart(1, 'ab') // 'x'

若用于补全的字符串与原字符串长度之和超过指定的最小长度，则截去超出位数的补全字符串：

'x'.padStart(5, 'ab') // 'ababx'
'x'.padStart(4, 'ab') // 'abax'

若省略第二个参数，默认使用空格补全长度：

'x'.padStart(4) // '   x'

padStart() 的常见用途是为数值补全指定位数。例如，将返回的页码补齐为三位，如第 1 页显示为 001，即可使用该方法实现：

"1".padStart(3, '0')   // 输出结果： '001'
"15".padStart(3, '0')  // 输出结果： '015'

（2）padEnd()

padEnd()用于尾部补全。该方法同样接收两个参数，第一个参数为字符串补全生效的最大长度，第二个参数为用于补全的字符串：

'x'.padEnd(5, 'ab') // 'xabab'
'x'.padEnd(4, 'ab') // 'xaba'

13. 字符串转为数字

parseInt() 和 parseFloat() 方法均用于将字符串转换为数字。

parseInt() 方法用于解析一个字符串，并返回一个整数。其语法如下：

parseInt() 函数用于解析一个字符串，并返回一个整数。其语法如下：

parseInt(string, radix)

该方法包含两个参数：

• string：必需参数，指定要被解析的字符串。
• radix：可选参数，表示要解析的数字的基数，取值范围为 2 至 36 之间。

当参数 radix 的值为 0，或未设置该参数时，parseInt() 会根据 string 来判断数字的基数。

parseInt("10");			  // 输出结果：10
parseInt("17",8);		  // 输出结果：15 (8+7)
parseInt("010");		  // 输出结果：10 或 8

当参数 radix 的值以 “0x” 或 “0X” 开头，将以 16 为基数：

parseInt("0x10")      // 输出结果：16

若该参数小于 2 或者大于 36，则 parseInt() 将返回 NaN：

parseInt("50", 1)      // 输出结果：NaN
parseInt("50", 40)     // 输出结果：NaN

仅返回字符串中的第一个数字，当遇到第一个非数字字符时停止解析：

parseInt("40 4years")   // 输出结果：40

若字符串的第一个字符无法转换为数字，则返回 NaN：

parseInt("new100")     // 输出结果：NaN

字符串开头和结尾的空格是允许的：

parseInt("  60  ")    // 输出结果： 60

（2）parseFloat()

parseFloat() 方法可解析一个字符串，并返回一个浮点数。该方法判断字符串中的首个字符是否为数字。若是，则对字符串进行解析，直到到达数字的末端为止，然后以数字形式返回该数字，而非作为字符串。其语法如下：

parseFloat(string)

parseFloat 将字符串参数解析为浮点数并返回。若在解析过程中遇到正负号（+ 或 -）、数字 (0-9)、小数点，或者科学记数法中的指数（e 或 E）以外的字符，则忽略该字符及其后的所有字符，返回当前已解析到的浮点数。同时，参数字符串首位的空白符会被忽略。

parseFloat("10.00")      // 输出结果：10.00
parseFloat("10.01")      // 输出结果：10.01
parseFloat("-10.01")     // 输出结果：-10.01
parseFloat("40.5 years") // 输出结果：40.5

若参数字符串的第一个字符无法解析为数字，则 parseFloat 返回 NaN。

parseFloat("new40.5")    // 输出结果：NaN

14.如何多次复制一个字符串

JS 字符串支持简单的重复操作，与手动复制字符串不同，我们可以使用字符串的 repeat 方法。

const laughing = '小智'.repeat(3)
consol.log(laughing) // "小智小智小智"

const eightBits = '1'.repeat(8)
console.log(eightBits) // "11111111"

15. 如何填充一个字符串到指定的长度

有时，我们希望字符串具有特定长度。若字符串太短，则需要填充剩余空间，直到达到指定的长度为止。

过去，主要依赖库 left-pad。如今，我们可以使用 padStart 和 SpadEnd 方法，具体选择取决于是在字符串开头还是结尾进行填充。

// 在开头添加 "0"，直到字符串的长度为 8。
const eightBits = '001'.padStart(8, '0')
console.log(eightBits) // "00000001"

//在末尾添加“ *”，直到字符串的长度为5。
const anonymizedCode = "34".padEnd(5, "*")
console.log(anonymizedCode) // "34***"

16.如何将字符串拆分为字符数组

有多种方法可将字符串分割为字符数组，我更倾向于使用扩展操作符 (...)：

const word = 'apple'
const characters = [...word]
console.log(characters) // ["a", "p", "p", "l", "e"]

注意，这并不总是如预期那样工作。更多信息请参阅下一个技巧。

17.如何计算字符串中的字符

可以使用 length 属性。

const word = "apple";
console.log(word.length) // 5

但对于中文字符，该方法可能不够准确。

const word = "𩸽"
console.log(word.length) // 2

日本汉字 𩸽 返回 length 为 2，原因何在？JS 将大多数字符表示为 16 位代码点。然而，某些字符由两个（或更多）16 位代码点表示，称为代理对。若使用 length 属性，JS 返回的是代码点的数量。因此，𩸽（hokke） 由两个代码点组成，导致返回错误的值。

如何准确判断？可使用解构操作符号 (...)。

const word = "𩸽"
const characters = [...word]
console.log(characters.length) // 1

这种方法在大多数情况下有效，但存在极端情况。例如，若使用表情符号，此长度计算也可能出错。若需准确计算字符长度，必须将单词分解为字素簇 (Grapheme Clusters)，这超出了本文范围，此处不再赘述。

18.如何反转字符串中的字符

反转字符串中的字符相对容易。只需组合扩展操作符 (...)、Array.reverse 方法和 Array.join 方法。

const word = "apple"
const reversedWord = [...word].reverse().join("")
console.log(reversedWord) // "elppa"

与前述情况类似，也存在边缘情况。遇到边缘情况时，需首先将单词拆分为字素簇。

19. 如何将字符串中的第一个字母大写

将字符串首字母大写是一个非常常见的操作。尽管许多编程语言提供了本地方法来实现此功能，但 JS 需要额外处理。

let word = 'apply'

word = word[0].toUpperCase() + word.substr(1)

console.log(word) // "Apple"

另一种方法：

// This shows an alternative way
let word = "apple";

// 使用扩展运算符（`...`）拆分为字符

const characters = [...word];
characters[0] = characters[0].toUpperCase();
word = characters.join("");

console.log(word); // "Apple"

20.如何在多个分隔符上分割字符串

假设我们要在分隔符上分割字符串，首先想到的便是使用 split 方法，这点大家肯定熟悉。但可能有人不知道，split 可同时拆分多个分隔符，使用正则表达式即可实现：

// 用逗号(,)和分号(;)分开。

const list = "apples,bananas;cherries"
const fruits = list.split(/[,;]/)
console.log(fruits); // ["apples", "bananas", "cherries"]

21.如何检查字符串是否包含特定序列

字符串搜索是一项常见任务。在 JS 中，你可以使用 String.includes 方法轻松完成此操作，无需正则表达式。

const text = "Hello, world! My name is Kai!"
console.log(text.includes("Kai")); // true

22.如何检查字符串是否以特定序列开头或结尾

在字符串的开头或结尾进行搜索，可使用 String.startsWith 和 String.endsWith 方法。

const text = "Hello, world! My name is Kai!"

console.log(text.startsWith("Hello")); // true

console.log(text.endsWith("world")); // false

23.如何替换所有出现的字符串

有多种方法可替换所有出现的字符串。可使用 String.replace 方法配合带有全局标志的正则表达式，或者使用新的 String.replaceAll 方法。请注意，此新方法并非在所有浏览器和 Node.js 版本中均可用。

const text = "I like apples. You like apples."

console.log(text.replace(/apples/g, "bananas"));
// "I like bananas. You like bananas."

console.log(text.replaceAll("apples", "bananas"));
// "I lik

24. JSON格式化和解析

JSON 并非仅限 JavaScript 的数据类型，广泛应用于前后端数据交互。JSON.stringify() 函数用于将对象转换为 JSON 格式的字符串。通常，只需将对象作为参数即可，如下所示：

const article = {
    title: "JavaScript 字符串技巧",
    view: 30000,
    comments: null,
    content: undefined,
};
const strArticle = JSON.stringify(article); 

console.log(strArticle); // {"title":"JavaScript 字符串技巧","view":30000,"comments":null}

从上述代码可见，在 stringify 中会过滤掉 undefined 的值，但 null 值不会。

JSON.stringify() 可接受两个可选参数，第二个参数为替换器，可在其中指定要打印的键的数组或清除它们的函数。如下代码：

console.log(JSON.stringify(article, ["title", "comments"])); // {"title":"JavaScript 字符串技巧","comments":null}
console.log(JSON.stringify(article, [])); // {}

对于巨大的 JSON，传递长数组可能影响可读性及效率。因此，可设置替换函数并为要跳过的键返回 undefined，如下代码：

const result = JSON.stringify(article, (key, value) =>
    key === "title" ? undefined : value
);
console.log(result); // {"view":30000,"comments":null}

JSON.stringify() 的第三个参数通过指定缩进（在嵌套块中很有用）来格式化 JSON，可传递数字设置缩进间距，或传递字符串替换空格。如下代码：

console.log(JSON.stringify(article, ["title"], "\t")); 

输出的格式如下：

{
    "title": "JavaScript 字符串技巧"
}

还有一个 JSON.parse() 函数，它接受一个 JSON 字符串并将其转换为 JavaScript 对象。它还接受一个 reviver 函数，可在返回值之前拦截对象属性并修改属性值。

const reviver = (key, value) => (key === "view" ? 0 : value);

var jsonString = JSON.stringify(article);
var jsonObj = JSON.parse(jsonString, reviver);

console.log(jsonObj); // { title: 'JavaScript 字符串技巧', view: 0, comments: null }

25. 多行字符串和嵌入式表达式

在 JavaScript 中有三种创建字符串的方式，可使用单引号 ''、双引号 "" 或反引号（键盘左上方， 1 的左边按键）。

const countries1 = "China";
const countries2 = "China";
const countries3 = `China`;

前两种创建方式基本相同，可混合使用以连接或添加带引号的字符串（通过使用相反的语法风格），而反引号可对字符串进行更强大且灵活的操作。

反引号也称为模板字面量，在创建多行字符串和嵌入表达式时十分方便。以下是如何在 JavaScript 中使用字符串插值创建多行字符串的代码：

const year = "2021";
const month = 7;
const day = 2;
const detail = `今天是${year}年${month}月${day}日，
是个不错的日子！`;

console.log(detail);

输出的结果也换行了，如下：

今天是2021年7月2日， 是个不错的日子！

除了字符串字面量，在 ${} 中允许任何有效的表达式，可以是函数调用或表达式，甚至是嵌套模板。

标记模板是模板字面量的一种高级形式，允许使用一个函数来解析模板字面量，其中内嵌的表达式作为参数。如下代码：

const title = "JavaScript 字符串技巧";
const view = 30000;

const detail = (text, titleExp, viewExp) => {
    const [string1, string2, string3] = [...text];
    return `${string1}${titleExp}${string2}${viewExp}${string3}`;
};

const intro = detail`本文的标题是《${title}》，当前阅读量是： ${view}`;

console.log(intro); // 文的标题是《JavaScript 字符串技巧》，当前阅读量是：30000

26. 验证字符串数组中是否存在子字符串

查找 JavaScript 字符串中是否存在子字符串是容易的事情，在 ES6 中，只需使用 includes 函数。

但需验证字符串是否存在于数据中，若主要数组中其中一项包含则返回 true，若都不包含则返回 false，因此需使用 some 函数与 includes 一起使用，如下代码：

const arrayTitles = ["Javascript", "EScript", "Golang"];
const hasText = (array, findText) =>
    array.some((item) => item.includes(findText));

console.log(hasText(arrayTitles, "script")); // true
console.log(hasText(arrayTitles, "php")); // false

参考文章

https://juejin.cn/post/6913691919386312712

到此这篇关于 javaScript 操作字符串的一些常用方法的文章就介绍到这了，更多相关 javaScript 操作字符串内容请搜索本站以前的文章或继续浏览下面的相关文章，希望大家以后多多支持本站！