Javascript的字符串方法详解 Javascript的字符串方法详解

字符串长度：length
获取字符串指定位置的值

charAt()
charCodeAt()

字符串检查是否包含某个值

indexOf()
lastIndexOf()
includes()
startsWith()
endsWith()

字符串拼接

concat
'+'号

字符串分割成数组

split()

截取字符串

slice()
substr()
substring()

字符串大小写转换

toLowerCase()
toUpperCase()

字符串模式匹配

replace()
replaceAll()
match()
search()

移除字符串空白符

trim()
trimStart()
trimEnd()

其他类型转为字符串

toString()
String()
隐式转换
JSON.stringify()

重复一个字符串

repeat()

补齐字符串长度

padStart()
padEnd()
parseFloat()
JSON.parse()
Number()

总结

字符串长度：length
获取字符串指定位置的值
charAt()
返回值

str.charAt(2)// cstr[2] // cstr.charAt(30)// ''str[30] // undefinde

当index的取值不在str的长度范围内时，str[index]会返回undefined，而charAt(index)会返回空字符串；
注意：str[index]不兼容ie6-ie8，charAt(index)可以兼容。

charCodeAt()
获取字符串索引位置字符的 Unicode 值

str.charAt(2)// cstr[2] // cstr.charAt(30)// ''str[30] // undefinde

字符串检查是否包含某个值
indexOf()
查找某个字符，有则返回第一次匹配到的索引位置，否则返回-1，正序查找：

str.indexOf('e')// 4 索引位置str.indexOf('e',5)// -1

语法：string.indexOf(value,startIndex)

value：必需，规定需检索的字符串值；
startIndex：可选的整数参数，默认0，正序查找开始检索的位置。它的合法取值是 0 到 string.length - 1

【Javascript的字符串方法详解】
lastIndexOf()
查找某个字符，有则返回最后一次匹配到的位置，否则返回-1，与indexOf相反，倒叙查找：

str.lastIndexOf('e')// 10str.lastIndexOf('e',8) // 倒叙查找0-8索引之内的e// 4str.lastIndexOf('e',3) // 倒叙查找0-3索引之内的e// -1

语法：string.lastIndexOf(value,startIndex)

value：必需，规定需检索的字符串值；
startIndex：可选的整数参数，默认string.length - 1，倒叙查找开始索引位置。它的合法取值是 0 到 string.length - 1

includes()
判断字符串是否包含指定的子字符串。如果找到匹配的字符串则返回 true，否则返回 false。

str.includes('e') // truestr.includes('e',11) // false

语法：string.includes(value, startIndex)

value：必需，规定需检索的字符串值；
startIndex：可选的整数参数，默认0，查找开始索引位置。它的合法取值是 0 到 string.length - 1

startsWith()
该方法用于检测字符串是否以指定的子字符串开始。如果是以指定的子字符串开头返回 true，否则 false。

str.startsWith('ab') // truestr.startsWith('ef') // falsestr.startsWith('ef',4) // true

语法：string.startsWith(value, startIndex)

value：必需，规定需检索的字符串值；
startIndex：可选的整数参数，默认0，查找开始索引位置。它的合法取值是 0 到 string.length - 1

endsWith()
该方法用来判断当前字符串是否是以指定的子字符串结尾。如果传入的子字符串在搜索字符串的末尾则返回 true，否则将返回 false。

str.endsWith('ba') // truestr.endsWith('ef') // falsestr.endsWith('ef',6) // true

语法：string.endsWith(value, length)

value：必需，规定需检索的字符串值；
length：子字符串的长度，默认为原始字符串长度string.length

字符串拼接
concat
连接两个或多个字符串。该方法不会改变原有字符串，会返回连接两个或多个字符串的新字符串。

let a = 'asdf'let b = '123'let s = a.concat(b)let s2 = a + bconsole(a,b,s,s2)// 'asdf''123''asdf123''asdf123'

语法：string.concat(string1, string2, ..., stringX)

? 在字符串string后面拼接string1、string2…stringX

'+'号
如上contact示例，一般使用此方法，简单高效

字符串分割成数组
split()
把一个字符串分割成字符串数组。该方法不会改变原始字符串。

str.split('') // ["a", "b", "c", "d", "e", "f", "g", "h", "g", "f", "e", "d", "c", "b", "a"]str.split('',4) // ["a", "b", "c", "d"]str.split('',20) // ["a", "b", "c", "d", "e", "f", "g", "h", "g", "f", "e", "d", "c", "b", "a"]

语法：string.split(separator,limit)

separator：必需。字符串或正则表达式，从该参数指定的地方分割 string
limit：可选。该参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。

截取字符串
slice()
提取字符串的某个部分，并以新的字符串返回被提取的部分。

str.slice(1,3) // bcstr.slice(-3,-1) // cb

语法： string.slice(start,end)

start：必须。要截取的片断的起始索引，第一个字符位置为 0。如果为负数，则从尾部开始截取；
end：可选。要截取的片段结尾的下标。若未指定此参数，则要提取的子串包括 start 到原字符串结尾的字符串。如果该参数是负数，那么它规定的是从字符串的尾部开始算起的位置。
如果start是负数，那么end应当大于start且小于0
该方法返回的子字符串包括start处的字符但不包括end处的字符

substr()
用于在字符串中抽取从开始下标开始的指定数目的字符。

str.substr(5) // fghgfedcbastr.substr(5,3) // fgh

语法： string.substr(start,length)

start：必需。要抽取的子串的起始下标。必须是数值。如果是负数，那么该参数声明从字符串的尾部开始算起的位置，可以为负数，表示从最后开始。
length：可选。子串中的字符数。必须是数值。如果省略了该参数，那么返回从 string 的开始位置到结尾的字串。

substring()
用于提取字符串中介于两个指定下标之间的字符

str.substring(3,5) // destr.substring(5,3) // de

语法：string.substring(start, end)

start：必需。一个非负的整数，规定要提取的子串的第一个字符在 string 中的位置。
end：可选。一个非负的整数，比要提取的子串的最后一个字符在 string 中的位置多 1。如果省略该参数，那么返回的子串会一直到字符串的结尾。
注意：
start和end均不接受负数返回的子串包含start不包含end如果start=end，返回空串如果start < end，该方法会自动交换这两个参数

字符串大小写转换
toLowerCase()
字符串转换为小写。

let t = 'AXC't.toLowerCase() // axc

toUpperCase()
字符串转换为大写。

str.toUpperCase() // ABCDEFGHGFEDCBA

字符串模式匹配
replace()
用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。

str.replace('b',11) // a11cdefghgfedcbastr.replace(/b/g,11) // a11cdefghgfedc11a g:表示全局,没有则默认替换第一个，i:表示忽略大小写

语法：string.replace(oldValue, newValue)

oldValue：必需。规定子字符串或要替换的模式的 RegExp 对象。如果该值是一个字符串，则将它作为要检索的直接量文本模式，而不是首先被转换为 RegExp 对象。
newValue：必需。一个字符串值。规定了替换文本或生成替换文本的函数。

replaceAll()
replace()方法的全局替换：
str.replace(/b/g,11) 等价于 str.replaceAll('b',11)

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

str.match('ghg') // ["ghg", index: 6, input: "abcdefghgfedcba", groups: undefined]str.match(/ghg/g) // ["ghg"]str.match(/a/g) // ["a", "a"]str.match(/t/g) // null

语法： string.match(regexp)

regexp 是必需的，规定要匹配的模式的 RegExp 对象。
该方法返回存放匹配结果的数组。该数组的内容依赖于 regexp 是否具有全局标志 g。

search()
用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串。

str.search(/ghg/) // 6str.search(/a/) // 0str.search(/a/g) // 0str.search(/t/g) // -1

语法： string.search(value)

regex 可以是需要在 string 中检索的子串，也可以是需要检索的 RegExp 对象。
注意：
要执行忽略大小写的检索，请追加标志 i。该方法不执行全局匹配，它将忽略标志 g，也就是只会返回第一次匹配成功的结果。如果没有找到任何匹配的子串，则返回 -1。返回 str 中第一个与 regexp 相匹配的子串的起始位置。

移除字符串空白符
trim()
用于移除字符串首尾空白符，该方法不会改变原始字符串。该方法不适用于null、undefined、Number类型

let s = ' 123 's.trim() // '123'

trimStart()
用于移除字符串开头空白符，该方法不会改变原始字符串。

let s = ' 123 's.trimStart() // '123 '

trimEnd()
用于移除字符串结尾空白符，该方法不会改变原始字符串。

let s = ' 123 's.trimEnd() // ' 123'

其他类型转为字符串
toString()
适用于：Boolean，Array，Number

let arr = [1,2,3]let num = 123let bool = truelet obj = {a:1}arr.toString()// '1,2,3'num.toString()// '123'bool.toString()// 'true'obj.toString()// '[object Object]'

语法：notStr.toString()

String()
适用于：Boolean，Array，Number

let arr = [1,2,3]let num = 123let bool = truelet obj = {a:1}String(arr)// '1,2,3'String(num)// '123'String(bool)// 'true'String(obj)// '[object Object]'

语法：String(notStr)

隐式转换
非字符串+字符串=字符串，先将原数据类型隐式转换为字符串，然后再加上新字符串。
适用于：Boolean，Array，Number，null

let arr = [1,2,3]let num = 123let bool = truelet obj = {a:1}arr+''// '1,2,3'arr+'t'// '1,2,3t'num+'t'// '123t'bool+''// 'true'obj+''// '[object Object]'null+'' // 'null'

JSON.stringify()
适用于：Boolean，Array，Number，null，undefined

let arr = [1,2,3]let num = 123let bool = truelet obj = {a:1}JSON.stringify(arr) // '[1,2,3]' 保留了中括号[]JSON.stringify(num) // '123'JSON.stringify(bool) // 'true'JSON.stringify(obj) // '{"a":1}'JSON.stringify(null) // 'null'JSON.stringify(NaN) // 'null'

还原使用JSON.parse()

let arr = [1,2,3]let num = 123let bool = truelet obj = {a:1}JSON.parse(JSON.stringify(arr)) // [1,2,3]JSON.parse(JSON.stringify(num)) // 123JSON.parse(JSON.stringify(bool)) // trueJSON.parse(JSON.stringify(obj)) // {a:1}JSON.parse(JSON.stringify(null)) // nullJSON.parse(JSON.stringify(NaN)) // null

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

'cv'.repeat(3) // 'cvcvcv''cv'.repeat(0) // '''cv'.repeat(2.6) // 'cvcv''cv'.repeat('3') // 'cvcvcv''cv'.repeat('3a') // ''

语法：string.repeat(number)

number：重复次数
注意：
为0，返回空子串向下取整负数或Infinity会报错0 到-1 之间的负小数或NaN，等同于0若number为字符串，会先转为数字类型数字类型字符串，会自动转为对应的数字，再repeat非数字类型的字符串，等同于0

补齐字符串长度
padStart()
头部补全

let t = 'mosowe't.padStart(1,'nb') // 'mosowe't.padStart(10,'nb') // 'nbnbmosowe't.padStart(10,'') // 'mosowe't.padStart(10)// 'mosowe'

语法：string.padStart(length,str)

length：字符串补齐之后的长度
str：用来补全的字符串
注意：
如果原字符串的长度，等于或大于指定的最小长度，则返回原字符串如果用来补全的字符串与原字符串，两者的长度之和超过了指定的最小长度，则会截去超出位数的补全字符串如果省略第二个参数，默认使用空格补全长度如果第二个参数为空字符串，则不会补全

padEnd()
末尾补全，参看padStart()
字符串转为数字 parseInt()

parseInt("10") // 10parseInt("10.11") // 10parseInt("16",8) // 14= 8+6, 转为八进制parseInt("010") // 10，据说有的浏览器是8，但是我试了好几款国内浏览器，都是10，parseInt("") // NaNparseInt("unh") // NaNparseInt("123tt") // 123parseInt("tt123") // NaN

语法：parseInt(string, radix)

string：必需。要被解析的字符串
radix：可选。表示要解析的数字的基数。该值介于 2 ~ 36 之间，默认10。

parseFloat()
转为十进制浮点数

parseFloat("10") // 10parseFloat("10.11") // 10.11parseFloat("10.11.11111") // 10.11parseFloat("010") // 10parseFloat("") // NaNparseFloat("unh") // NaNparseFloat("123tt") // 123parseFloat("tt123") // NaN

语法：parseFloat(string)

JSON.parse()

JSON.parse("10") // 10JSON.parse("10.11") // 10.11JSON.parse("10.11.11111") // errorJSON.parse("010") // errorJSON.parse("") // errorJSON.parse("unh") // errorJSON.parse("123tt") // errorJSON.parse("tt123") // error

语法：JSON.parse(string)

Number()