string

属性与方法

名称	类型	参数	返回值	说明
`length`	属性		`int`	获取字符串长度
`after`	方法	`str:string`	`string`	返回指定字符串首次出现时的位置之后的子字符串
`afterLast`	方法	`str:string`	`string`	返回指定字符串最后一次出现时的位置之后的子字符串
`before`	方法	`str:string`	`string`	返回指定字符串第一次出现时的位置之前的子字符串
`beforeLast`	方法	`str:string`	`string`	返回指定字符串最后一次出现时的位置之前的子字符串
`camelCase`	方法		`string`	返回字符串的驼峰格式,非字母和数字会被忽略
`kebabCase`	方法		`string`	返回字符串的kebab-case格式,忽略特殊字符
`snakeCase`	方法		`string`	返回字符串的snake_case格式串
`compare`	方法	`str:string`	`int`	比较两个字符串串
`count`	方法	`str:string`	`int`	统计子字符串出现的次数
`endsWith`	方法	`endStr:string`	`boolean`	检查字符串是否以指定后缀结尾
`startsWith`	方法	`startStr:string`	`boolean`	检查字符串是否以给定的子字符串开头
`endsWithAny`	方法	`endStrs:string[]`	`boolean`	检查字符串是否以指定字符串数组中的任何一个结尾
`startsWithAny`	方法	`startStrs:string[]`	`boolean`	检查字符串是否以指定字符串数组中的任何一个开头
`equalFold`	方法	`str:string`	`boolean`	忽略大小写地比较两个字符串是否相等
`fields`	方法		`string[]`	将字符串按照空白字符分割成若干子串，并去掉所有的空白字符
`fieldsFunc`	方法	`func:Function`	`string[]`	根据回调函数的结果将字符串分割成若干子串
`includes`	方法	`str:string`	`boolean`	检查当前字符串是否包含子字符串
`includesAny`	方法	`arrStr:string[]`	`boolean`	检查当前字符串是否包含数组中的任意一个元素
`indexAny`	方法	`chars:string`	`int`	查找当前字符串中第一个包含指定字符串中的任意一个字符的位置，并返回其索引
`indexFunc`	方法	`func:Function`	`int`	查找字符串中第一个符合指定条件的字符的位置，并返回其索引
`indexOffset`	方法	`str:string, idxFrom:int`	`number`	将字符串偏移 idxFrom 后，返回字符串中第一个 substr 实例的索引
`indexOf`	方法	`str:string`	`int`	获取字符串中给定子字符串第一次出现的位置
`lastIndexAny`	方法	`chars:string`	`int`	查找字符串中最后一个包含指定字符串中的任意一个字符的位置，并返回其索引
`lastIndexFunc`	方法	`func:Function`	`int`	查找字符串中最后一个符合指定条件的字符的位置，并返回其索引
`lastIndexOf`	方法	`str:string`	`int`	查找子字符串在字符串中最后一次出现的位置，并返回其索引
`isBlank`	方法		`boolean`	检查字符串是否为空白字符串
`isNotBlank`	方法		`boolean`	检查字符串是否不为空
`pad`	方法	`size:int, padStr:string`	`string`	如果字符串长度短于 size，则在左右两侧用给定字符填充字符串
`padEnd`	方法	`size:int, padStr:string`	`string`	如果字符串短于限制大小，则在右侧用给定字符填充字符串
`padStart`	方法	`size:int, padStr:string`	`string`	如果字符串短于限制大小，则在左侧用给定字符填充字符串
`repeat`	方法	`count:int`	`string`	将一个字符串重复指定次数并返回一个新的字符串
`replace`	方法	`old:string, new:string, n?:int`	`string`	将字符串中指定的子字符串替换为另一个子字符串，替换次数由用户指定。
`removeNonPrintable`	方法		`string`	删除字符串中不可打印的字符
`reverse`	方法		`string`	返回字符顺序与给定字符串相反的字符串
`split`	方法	`sep:string, n?:int`	`string[]`	根据指定的分隔符将字符串拆分为子字符串数组，可选限制拆分次数
`splitAfter`	方法	`sep:string, n?:int`	`string[]`	根据指定的分隔符将字符串拆分为子字符串数组，每个子字符串包含分隔符，可选限制拆分次数
`splitEx`	方法	`sep:string, removeEmptyString:boolean`	`string[]`	根据指定的分隔符将字符串拆分为子字符串数组,且不包含空字符串
`substring`	方法	`start:int, length?:int`	`string`	根据指定的位置和长度截取子字符串
`subInBetween`	方法	`start:string, end:string`	`string`	获取字符串中指定的起始字符串start和终止字符串end之间的子字符串
`lowerFirst`	方法		`string`	将字符串的第一个字符转换为小写
`toLower`	方法		`string`	将字符串中的所有字符转换为小写
`upperFirst`	方法		`string`	将字符串的第一个字符转换为大写
`toUpper`	方法		`string`	将字符串中的所有字符转换为大写
`trim`	方法	`cutset?:string`	`string`	移除字符串两端的空白字符,可以指定移除指定字符
`trimStart`	方法	`prefix?:string`	`string`	移除字符串左侧的空白字符 ,可以指定移除指定字符
`trimEnd`	方法	`suffix?:string`	`string`	移除字符串右侧的空白字符 ,可以指定移除指定字符
`charAt`	方法	`index:int`	`string`	返回指定索引位置的字符
`charCodeAt`	方法	`index:int`	`int`	返回指定索引位置的字符的 Unicode 值
`match`	方法	`regexp:regexp`	`any[]`	在字符串中检索指定的值
`slice`	方法	`beginIndex:int, endIndex?:int`	`string`	提取字符串的一部分
`decodeURI`	方法	`str:string`	`string`	将经过编码的 URI 或 URL 解码为原始字符串
`encodeURI`	方法	`str:string`	`string`	字符串转换为 URI（Uniform Resource Identifier）的格式
`toBuffer`	方法	`charset?:string`	`Buffer`	字符串转换为Buffer

length

获取字符串的长度。

示例

// 获取字符串 "hello world" 的长度
let result = "hello world".length;
console.log(result); // 输出: 11

// 获取空字符串的长度
result = "".length;
console.log(result); // 输出: 0

after

返回源字符串中指定字符串首次出现时的位置之后的子字符串。如果没有指定字符串，则返回原字符串。

语法

after(str:string)

参数

str:string 指定字符串

示例

let result = "hello world".after("hello");
console.log(result); // 输出: " world"

let result1 = "hello world ".after("ow");
console.log(result1); // 输出: "hello world"

afterLast

返回源字符串中指定字符串最后一次出现时的位置之后的子字符串。如果没有指定字符串，则返回原字符串。

语法

afterLast(str:string)

参数

str:string 指定字符串

示例

let result = "hello world hello".afterLast("hello");
console.log(result); // 输出: ""

let result2 = "hello world hello".afterLast("world");
console.log(result2); // 输出: " hello"

let result3 = "hello world hello".afterLast("aaa");
console.log(result3); // 输出: "hello world hello"

before

返回源字符串中指定字符串第一次出现时的位置之前的子字符串。如果没有指定字符串，则返回原字符串。

语法

before(str:string)

参数

str:string 指定字符串

示例

let result = "hello world".before("world");
console.log(result); // 输出: "hello "

let result2 = "hello world".before("hello");
console.log(result2); // 输出: ""

let result3 = "hello world".before("aaa");
console.log(result3); // 输出: "hello world"

beforeLast

返回源字符串中指定字符串最后一次出现时的位置之前的子字符串。

语法

beforeLast(str:string)

参数

str:string 指定字符串

示例

let result = "hello world hello".beforeLast("hello");
console.log(result); // 输出: "hello world "

let result1 = "hello world hello".beforeLast("aaa");
console.log(result1); // 输出: "hello world hello"

camelCase

将字符串转换为 CamelCase 驼峰式字符串。

语法

camelCase()

示例

let result = "hello world".camelCase();
console.log(result); // 输出: "helloWorld"

kebabCase

将字符串转换为 kebab-case 形式字符串。

语法

kebabCase()

示例

// 结果为 "hello-world"
let result = "hello world".kebabCase();
console.log(result); // 输出: "hello-world"

let result = "helloWorld, hello vino".kebabCase();
console.log(result); // 输出: "hello-world-hello-vino"

snakeCase

将字符串转换为 snake_case 形式。

语法

snakeCase()

示例

// 结果为 "hello_world"
let result = "hello world".snakeCase();
console.log(result); // 输出: "hello_world"

let result = "helloWorld, hello vino".snakeCase();
console.log(result); // 输出: "hello_world_hello_vino"

compare

比较两个字符串。

语法

compare(str:string)

参数

str:string 指定字符串

示例

// "a" 小于 "b"
let result = "a".compare("b");
console.log(result); // 输出: -1

// "b" 大于 "a"
result = "b".compare("a");
console.log(result); // 输出: 1

// "a" 等于 "a"
result = "a".compare("a");
console.log(result); // 输出: 0

count

统计子字符串出现的次数。

语法

count(str:string)

参数

str:string 子字符串

示例

// "o" 出现了 2 次
let result = "hello world".count("o");
console.log(result); // 输出: 2

// "l" 出现了 3 次
result = "hello world".count("l");
console.log(result); // 输出: 3

endsWith

检查字符串是否以指定后缀结尾。

语法

endsWith(str:string)

参数

str:string 后缀

示例

// 以 "world" 结尾
let result = "hello world".endsWith("world");
console.log(result); // 输出: true

// 不以 "hello" 结尾
result = "hello world".endsWith("hello");
console.log(result); // 输出: false

startsWith

检查字符串是否以指定前缀开头。

语法

startsWith(str:string)

参数

str:string 前缀

示例

// 以 "hello" 开头
let result = "hello world".startsWith("hello");
console.log(result); // 输出: true

// 不以 "world" 开头
result = "hello world".startsWith("world");
console.log(result); // 输出: false

endsWithAny

检查字符串是否以指定字符串数组中的任何一个结尾。

语法

startsWith(str:string[])

参数

str:string[] 前缀

示例

// 以 "world" 结尾
let result = "hello world".endsWithAny(["world", "planet"]);
console.log(result); // 输出: true

// 不以任意一个后缀结尾
result = "hello world".endsWithAny(["planet", "earth"]);
console.log(result); // 输出: false

startsWithAny

检查字符串是否以指定字符串数组中的任何一个开头。

示例

// 以 "hello" 开头
let result = "hello world".startsWithAny(["hello", "planet"]);
console.log(result); // 输出: true

// 不以任意一个前缀开头
result = "hello world".startsWithAny(["planet", "earth"]);
console.log(result); // 输出: false

equalFold

检查两个字符串是否相等（忽略大小写）。

示例

// "Go" 与 "go" 相等
let result = "Go".equalFold("go");
console.log(result); // 输出: true

// "Go" 与 "golang" 不相等
result = "Go".equalFold("golang");
console.log(result); // 输出: false

fields

将字符串分割为字段。

示例

// 分割字符串
let result = "  foo bar  baz ".fields();
console.log(result); // 输出: ["foo", "bar", "baz"]

fieldsFunc

按指定函数分割字符串。

示例

// 分割字符串
let result = " foo,bar,baz ".fieldsFunc(ch => ch === ',');
console.log(result); // 输出: [" foo", "bar", "baz "]

includes

检查字符串是否包含子字符串。

示例

// 包含子字符串 "world"
let result = "hello world".includes("world");
console.log(result); // 输出: true

// 不包含子字符串 "planet"
result = "hello world".includes("planet");
console.log(result); // 输出: false

includesAny

检查字符串是否包含任意一个字符。

示例

// 包含任意一个元音字母
let result = "hello world".includesAny("aeiou");
console.log(result); // 输出: true

// 不包含任意一个字符 "xyz"
result = "hello world".includesAny("xyz");
console.log(result); // 输出: false

indexAny

获取任意一个字符首次出现的位置。

示例

// 第一个元音字母出现在位置 1
let result = "hello world".indexAny("aeiou");
console.log(result); // 输出: 1

// 不存在字符 "xyz"，返回 -1
result = "hello world".indexAny("xyz");
console.log(result); // 输出: -1

indexFunc

按指定函数获取字符首次出现的位置。

示例

// "w" 出现在位置 6
let result = "hello world".indexFunc(ch => ch === 'w');
console.log(result); // 输出: 6

indexOffset

将字符串偏移 idxFrom 后，返回字符串中第一个 substr 实例的索引。

示例

// 结果为 6
let result = "hello world".indexOffset("world", 3);
console.log(result); // 输出: 6

indexOf

获取子字符串首次出现的位置。

示例

// "world" 首次出现的位置是 6
let result = "hello world".indexOf("world");
console.log(result); // 输出: 6

// "planet" 不存在，返回 -1
result = "hello world".indexOf("planet");
console.log(result); // 输出: -1

lastIndexAny

获取任意一个字符最后出现的位置。

示例

// 任意一个字符 "g" 或 "o" 最后出现的位置是 4
let result = "go gopher".lastIndexAny("go");
console.log(result); // 输出: 4

lastIndexFunc

按指定函数获取字符最后出现的位置。

示例

// "g" 最后出现的位置是 3
let result = "go gopher".lastIndexFunc(ch => ch === 'g');
console.log(result); // 输出: 3

lastIndexOf

获取子字符串最后出现的位置。

示例

// "go" 最后出现的位置是 3
let result = "go gopher".lastIndexOf("go");
console.log(result); // 输出: 3

// "fox" 不存在，返回 -1
result = "go gopher".lastIndexOf("fox");
console.log(result); // 输出: -1

isBlank

检查字符串是否为空格或空。

示例

// 是空白字符串
let result = "   ".isBlank();
console.log(result); // 输出: true

// 不是空白字符串
result = "hello".isBlank();
console.log(result); // 输出: false

isNotBlank

检查字符串是否不为空。

示例

// 是空白字符串
let result = "   ".isNotBlank();
console.log(result); // 输出: false

// 不是空白字符串
result = "hello".isNotBlank();
console.log(result); // 输出: true

pad

如果字符串长度短于 size，则在左右两侧填充字符串。

示例

// 结果为 "**hello***"
let result = "hello".pad(10, "*");
console.log(result); // 输出: "**hello***"

padEnd

如果字符串短于限制大小，则在右侧用给定字符填充字符串。

示例

// 结果为 "hello*****"
let result = "hello".padEnd(10, "*");
console.log(result); // 输出: "hello*****"

padStart

如果字符串短于限制大小，则在左侧用给定字符填充字符串。

示例

// 结果为 "*****hello"
let result = "hello".padStart(10, "*");
console.log(result); // 输出: "*****hello"

repeat

重复字符串。

示例

// 重复 "go" 三次，结果为 "gogogo"
let result = "go".repeat(3);
console.log(result); // 输出: "gogogo"

replace

替换子字符串。

示例

// 替换第一个 "foo" 为 "baz"
let result = "foo bar foo".replace("foo", "baz", 1);
console.log(result); // 输出: "baz bar foo"

// 替换两次 "k" 为 "ky"
let result1 = "oink oink oink".replace("k", "ky", 2);
console.log(result1); // 输出: "oinky oinky oink"

// 替换"oink" 为 "moo"
let result2 = "oink oink oink".replace("oink", "moo");
console.log(result2); // 输出: "moo moo moo"

removeNonPrintable

删除字符串中不可打印的字符。

示例

// 结果为 "helloworld"
let result = "hello\x00world".removeNonPrintable();
console.log(result); // 输出: "helloworld"

reverse

返回字符顺序与给定字符串相反的字符串。

示例

// 结果为 "olleh"
let result = "hello".reverse();
console.log(result); // 输出: "olleh"

split

按指定分隔符拆分字符串。

示例

// 拆分成 ["a", "b", "c"]
let result = "a,b,c".split(",");
console.log(result); // 输出: ["a", "b", "c"]

// 指定拆分次数为3次： 拆分成 ["a", "b", "c,d"]
let result2 = "a,b,c,d".split(",", 3);
console.log(result2); // 输出: ["a", "b", "c,d"]

splitAfter

按指定分隔符拆分字符串，包含分隔符。

示例

// 拆分成 ["a,", "b,", "c"]
let result = "a,b,c".splitAfter(",");
console.log(result); // 输出: ["a,", "b,", "c"]

// 指定拆分次数为3次： 拆分成 ["a,", "b,", "c,d"]
let result2 = "a,b,c,d".splitAfter(",", 3);
console.log(result2); // 输出: ["a,", "b,", "c,d"]

splitEx

拆分给定的字符串可以控制结果切片是否包含空字符串。

示例

let result = "a,b,c".splitEx(",", true);
console.log(result); // 输出: ["a", "b", "c"]

substring

根据指定的位置和长度截取子字符串。

示例

// 结果为 "hello"
let result = "hello world".substring(0, 5);
console.log(result); // 输出: "hello"

subInBetween

获取字符串中指定的起始字符串 start 和终止字符串 end 直接的子字符串。

示例

// 结果为 "llo wor"
let result = "hello world".subInBetween("he", "ld");
console.log(result); // 输出: "llo wor"

lowerFirst

将字符串的第一个字符转换为小写形式。

示例

// 结果为 "hello"
let result = "Hello".lowerFirst();
console.log(result); // 输出: "hello"

toLower

将字符串转换为小写。

示例

// 转换为 "hello"
let result = "HELLO".toLower();
console.log(result); // 输出: "hello"

upperFirst

将字符串的第一个字符转换为大写形式。

示例

// 结果为 "Hello"
let result = "hello".upperFirst();
console.log(result); // 输出: "Hello"

toUpper

将字符串转换为大写。

示例

// 转换为 "HELLO"
let result = "hello".toUpper();
console.log(result); // 输出: "HELLO"

trim

修剪指定字符。没有指定字符时,默认移除2端的空白字符

示例

// 修剪结果为 "hello"
let result = "!!!hello!!!".trim("!");
console.log(result); // 输出: "hello"

//打印结果:hello world
console.log(" hello world ".trim())

trimStart

修剪指定前缀。没有指定字符时,默认移除前缀的空白字符

示例

// 修剪结果为 "hello!!!"
let result = "!!!hello!!!".trimPrefix("!!!");
console.log(result); // 输出: "hello!!!"

trimEnd

修剪指定后缀。没有指定字符时,默认移除后缀的空白字符

示例

// 修剪结果为 "!!!hello"
let result = "!!!hello!!!".trimEnds("!!!");
console.log(result); // 输出: "!!!hello"

charAt

charAt()方法用于返回指定索引位置的字符。字符串中的第一个字符的索引是 0，第二个字符的索引是 1，以此类推。

语法

str.charAt(index);

参数

index：要返回的字符的索引位置。如果索引超出了字符串的范围，则返回空字符串。

示例

let str = "Hello, world!";
console.log(str.charAt(0)); // 输出: "H"
console.log(str.charAt(7)); // 输出: "w"
console.log(str.charAt(12)); // 输出: "!"
console.log(str.charAt(20)); // 输出: ""

charCodeAt

charCodeAt() 方法用于返回指定索引位置的字符的 Unicode 编码。字符串中的第一个字符的索引是 0，第二个字符的索引是 1，以此类推。

语法

str.charCodeAt(index);

参数

index：要返回的字符的索引位置。

返回值

返回指定索引位置的字符的 Unicode 编码。如果索引超出了字符串的范围，则返回 NaN。

示例

let str = "Hello, world!";
console.log(str.charCodeAt(0)); // 输出: 72 (字符 "H" 的 Unicode 编码)
console.log(str.charCodeAt(7)); // 输出: 119 (字符 "w" 的 Unicode 编码)
console.log(str.charCodeAt(12)); // 输出: 33 (字符 "!" 的 Unicode 编码)
console.log(str.charCodeAt(20)); // 输出: NaN (索引超出范围)

match

match() 方法用于在字符串中搜索指定的模式，并返回所有匹配的子字符串组成的数组。如果未找到匹配的子字符串，则返回 null。

语法

str.match(regexp);

参数

regexp：正则表达式对象

返回值

如果找到了匹配的子字符串，则返回一个包含所有匹配的子字符串组成的数组；否则返回 null。

示例

let str = "The rain in Spain falls mainly in the plain";

let matches = str.match(/ain/g); // 在字符串中查找所有以 "ain" 结尾的子字符串
console.log(matches); // 输出: ["ain", "ain", "ain", "ain"]

matches = str.match(/ain/gi); // 在字符串中查找所有以 "ain" 结尾的子字符串（不区分大小写）
console.log(matches); // 输出: ["ain", "ain", "Ain", "ain", "ain"]

matches = str.match(/abc/g); // 在字符串中查找所有以 "abc" 结尾的子字符串
console.log(matches); // 输出: null

slice

slice() 方法用于提取字符串中的一部分，并返回一个新的字符串，而不会改变原始字符串。

语法

str.slice(beginIndex[, endIndex]);

str：要操作的字符串。
beginIndex：要提取的子字符串的起始索引（包括）。
endIndex（可选）：要提取的子字符串的结束索引（不包括）。如果未指定 endIndex，则提取到字符串的末尾。

返回值

返回一个新的字符串，包含原始字符串中从 beginIndex 到 endIndex （不包括）的子字符串。

示例

let str = "Hello, world!";

let subStr = str.slice(7); // 从索引位置7开始提取到字符串末尾
console.log(subStr); // 输出: "world!"

subStr = str.slice(0, 5); // 从索引位置0开始提取到索引位置5之前（不包括5）
console.log(subStr); // 输出: "Hello"

subStr = str.slice(-6); // 从字符串末尾向前数，提取最后6个字符
console.log(subStr); // 输出: "world!"

subStr = str.slice(7, -1); // 从索引位置7开始提取到倒数第二个字符之前（不包括倒数第二个字符）
console.log(subStr); // 输出: "world"

encodeURI

encodeURI() 函数用于将字符串转换为 URI（Uniform Resource Identifier）的格式。它主要用于对 URL 中的特殊字符进行编码，以便在网络上传输时保持 URL 的有效性和完整性。

语法

uri.encodeURI();

uri：要进行编码的 URI 或 URL。

返回值

返回一个新的字符串，表示编码后的 URI 或 URL。

示例

let url = "https://www.example.com?name=John Doe&age=30";
let encodedUrl = url.encodeURI();
console.log(encodedUrl);
// 输出：https%3A%2F%2Fwww.example.com%3Fname%3DJohn+Doe%26age%3D30

注意事项:

encodeURI() 函数会对完整的 URL 进行编码，只对特殊字符编码，比如空格、冒号、斜杠等。不会对所有的字符进行编码。如果需要对完整的 URL。
encodeURI() 不会对 ASCII 字母和数字进行编码，因为它们在 URI 中是安全的。

总之，encodeURI() 函数对于对 URL 中的特殊字符进行编码是非常有用的，可以确保 URL 在网络传输中的有效性和完整性

decodeURI

decodeURI() 函数用于将经过编码的 URI 或 URL 解码为原始字符串。它主要用于将经过 encodeURI() 函数编码过的字符串解码为原始的 URI 或 URL 格式。

语法

encodedURI.decodeURI();

encodedURI：要进行解码的已编码 URI 或 URL。

返回值

返回一个新的字符串，表示解码后的原始 URI 或 URL。

示例

let uri = "https://www.example.com?name=John%20Doe&age=30";
let decodedUrl = uri.decodeURI();
console.log(decodedUrl);
// 输出：https://www.example.com?name=John Doe&age=30

注意事项

使用 decodeURI() 函数时要确保传递的字符串是经过编码的，否则可能会导致解码失败或错误结果。
decodeURI() 函数只能解码通过 encodeURI() 函数编码过的字符串

总之，decodeURI() 函数对于解码经过 encodeURI() 函数编码过的字符串是非常有用的，可以将编码后的字符串还原为原始的 URI 或 URL 格式。

toBuffer

用于将字符串转为Buffer对象

语法

toBuffer(charset?:string)

参数

charset: 解码的方式,默认:utf8

utf8
base64
hex 16进制字符串

示例

//字符串转buffer
let buffer = "你好vino".toBuffer()
//buffer转字符串
//打印:你好vino
console.log(buffer.toString());

let b1 = "FFEE".toBuffer("hex")
//打印ffee
console.log(b1.toString("hex"))

提示

vino中的字符串默认都是utf8的编码
如果需要创建其他编码的字符串,请使用Buffer对象的write方法。

string

ON THIS PAGE