Detailed explanation of Javascript string methods

String length: length

Get the value at a specified position in a string

charAt()

Return Value

str.charAt(2) // c
str[2] // c
str.charAt(30) // ''
str[30] // undefined

When the value of index is not within the length range of str, str[index] will return undefined, and charAt(index) will return an empty string;

Note: str[index] is not compatible with ie6-ie8, but charAt(index) is compatible.

charCodeAt()

Get the Unicode value of the character at the string index position

str.charAt(2) // c
str[2] // c
str.charAt(30) // ''
str[30] // undefined

Check if a string contains a value

indexOf()

Search for a character and return the index position of the first match if found , otherwise return -1, searching in positive order:

str.indexOf('e')
// 4 index position str.indexOf('e',5)
// -1

Syntax: string.indexOf(value,startIndex)

value: required, specifies the string value to be retrieved;

startIndex: An optional integer parameter, with a default value of 0, which means the starting position for searching in positive order. Its legal value is 0 to string.length - 1

lastIndexOf()

Search for a character, return the last matching position if found, otherwise return -1, opposite to indexOf, search in reverse order:

str.lastIndexOf('e')
// 10
str.lastIndexOf('e',8) // Search in reverse order for e within the 0-8 index
// 4
str.lastIndexOf('e',3) // Search in reverse order for e within the 0-3 indexes
// -1

Syntax: string.lastIndexOf(value,startIndex)

value: required, specifies the string value to be retrieved;

startIndex: An optional integer parameter, the default value is string.length - 1, which is used to search the start index position in reverse order. Its legal value is 0 to string.length - 1

includes()

Determines whether a string contains a specified substring. Returns true if a matching string is found, false otherwise.

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

Syntax: string.includes(value, startIndex)

value: required, specifies the string value to be retrieved;

startIndex: An optional integer parameter, default is 0, and the search starts at the index position. Its legal value is 0 to string.length - 1

startsWith()

This method is used to detect whether a string starts with a specified substring. Returns true if it starts with the specified substring, otherwise false.

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

Syntax: string.startsWith(value, startIndex)

value: required, specifies the string value to be retrieved;

startIndex: An optional integer parameter, default is 0, and the search starts at the index position. Its legal value is 0 to string.length - 1

endsWith()

This method is used to determine whether the current string ends with the specified substring. Returns true if the passed substring is at the end of the search string, otherwise returns false.

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

Syntax: string.endsWith(value, length)

value: required, specifies the string value to be retrieved;

length: The length of the substring, the default is the original string length string.length

String concatenation

concat

Concatenates two or more strings. This method does not change the original string, but returns a new string that concatenates two or more strings.

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

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

​ Concatenate string1, string2... stringX after string

'+' sign

As shown in the contact example above, this method is generally used, which is simple and efficient

Split string into array

split()

Split a string into an array of strings. This method does not change the original string.

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"]

Syntax: string.split(separator,limit)

separator: required. String or regular expression, split string from the place specified by this parameter

limit: Optional. This parameter specifies the maximum length of the returned array. If this parameter is set, no more substrings will be returned than the array specified by this parameter. If this parameter is not set, the entire string will be split regardless of its length.

Intercepting a string

slice()

Extracts a portion of a string and returns the extracted portion as a new string.

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

Syntax: string.slice(start,end)

start: Required. The starting index of the segment to be extracted, with the first character at position 0. If it is a negative number, it will be cut from the end;

end: Optional. The index of the end of the segment to be truncated. If this parameter is not specified, the substring to be extracted includes the string from start to the end of the original string. If this parameter is negative, it specifies the position from the end of the string.

If start is a negative number, then end should be greater than start and less than 0

The substring returned by this method includes the characters at start but does not include the characters at end.

substr()

Used to extract a specified number of characters from a string starting from the start subscript.

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

Syntax: string.substr(start,length)

start: Required. The starting index of the substring to be extracted. Must be a numeric value. If it is a negative number, the parameter declares the position starting from the end of the string. It can be a negative number, indicating starting from the end.

length: optional. The number of characters in the substring. Must be a numeric value. If this parameter is omitted, the string from the beginning to the end of string is returned.

substring()

Used to extract characters between two specified subscripts in a string

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

Syntax: string.substring(start, end)

start: Required. A non-negative integer that specifies the position in string of the first character of the substring to be extracted.

end: Optional. A nonnegative integer that is one more than the position in string of the last character of the substring to be extracted. If this parameter is omitted, the returned substring will end at the end of the string.

Notice:

Neither start nor end accepts negative numbers. The returned substring contains start but not end. If start = end, an empty string is returned. If start < end, the method automatically swaps the two parameters.

String case conversion

toLowerCase()

Converts a string to lower case.

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

toUpperCase()

Converts a string to upper case.

str.toUpperCase() // ABCDEFGHGFEDCBA

String pattern matching

replace()

Used to replace some characters in a string with other characters, or to replace a substring that matches a regular expression.

str.replace('b',11) // a11cdefghgfedcba
str.replace(/b/g,11) // a11cdefghgfedc11a g: means global, if not, replace the first one by default, i: means ignore case

Syntax: string.replace(oldValue, newValue)

oldValue: required. A RegExp object specifying the substring or pattern to be replaced. If the value is a string, it is treated as a literal text pattern to be retrieved, rather than being converted to a RegExp object first.

newValue: required. A string value. Specifies replacement text or a function that generates replacement text.

replaceAll()

Global replacement of replace() method:

str.replace(/b/g,11) is equivalent to str.replaceAll('b',11)

match()

Used to search for a specified value within a string, or to find matches for one or more regular expressions. This method is similar to indexOf() and lastIndexOf(), but it returns the specified value instead of the position in the string.

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

Syntax: string.match(regexp)

regexp Required; a RegExp object specifying the pattern to match.

This method returns an array containing the matching results. The contents of this array depend on whether regexp has the global flag g.

search()

Used to search for a specified substring in a string, or to search for a substring that matches a regular expression.

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

Syntax: string.search(value)

regex can be a substring to be searched in string, or a RegExp object to be searched.

Notice:

To perform a case-insensitive search, append the i flag. This method does not perform global matching, it will ignore the flag g, that is, only the result of the first successful match will be returned. If no matching substring is found, -1 is returned. Returns the starting position of the first substring in str that matches regexp.

Remove whitespace from a string

trim()

Used to remove leading and trailing whitespace characters from a string. This method does not change the original string. This method is not applicable to null, undefined, and Number types.

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

trimStart()

Used to remove whitespace at the beginning of a string. This method does not change the original string.

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

trimEnd()

Used to remove the trailing whitespace character of a string. This method does not change the original string.

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

Other types are converted to strings

toString()

Applies to: Boolean , Array , Number

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

Syntax: notStr.toString()

String()

Applies to: Boolean , Array , Number

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

Syntax: String(notStr)

Implicit Conversion

Non-string + string = string, first implicitly convert the original data type to a string, and then add the new string.

Applies to: Boolean , Array , Number , null

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

JSON.stringify()

Applies to: Boolean , Array , Number , null , undefined

let arr = [1,2,3]
let num = 123
let bool = true
let obj = {a:1}
JSON.stringify(arr) // '[1,2,3]' retains the brackets []
JSON.stringify(num) // '123'
JSON.stringify(bool) // 'true'
JSON.stringify(obj) // '{"a":1}'
JSON.stringify(null) // 'null'
JSON.stringify(NaN) // 'null'

Restore using JSON.parse()

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

Repeat a string

repeat()

Returns a new string, which means repeating the original string n times.

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

Syntax: string.repeat(number)

number: number of repetitions

Notice:

If it is 0, an empty substring is returned. If it is rounded down to the integer of a negative number or Infinity, an error will be reported. A negative decimal between 0 and -1 or NaN is equivalent to 0. If number is a string, it will be converted to a numeric type first. A numeric type string will automatically be converted to the corresponding number, and then repeat the non-numeric type string, which is equivalent to 0.

Padding string length

padStart()

Header completion

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

Syntax: string.padStart(length,str)

length: the length of the string after padding

str: string to be completed

Notice:

If the length of the original string is equal to or greater than the specified minimum length, the original string is returned. If the sum of the lengths of the string to be completed and the original string exceeds the specified minimum length, the completed string will be truncated if the second parameter is omitted. By default, spaces are used to complete the length. If the second parameter is an empty string, no completion is performed.

padEnd()

End completion, see padStart()

Convert string to number parseInt()

parseInt("10") // 10
parseInt("10.11") // 10
parseInt("16",8) // 14 = 8+6, convert to octal parseInt("010") // 10. Some browsers are said to be 8, but I tried several domestic browsers and they were all 10.
parseInt("") // NaN
parseInt("unh") // NaN
parseInt("123tt") // 123
parseInt("tt123") // NaN

Syntax: parseInt(string, radix)

string: required. The string to be parsed

radix: Optional. Indicates the base of the number to be parsed. The value ranges from 2 to 36, and the default is 10.

parseFloat()

Convert to decimal floating point number

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

Syntax: parseFloat(string)

JSON.parse()

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

Syntax: JSON.parse(string)

Number()

Number('') // 0
Number('10') // 10
Number('010') // 10
Number('2.3') // 2.3
Number('2.3.3') // NaN
Number('2TT') // NaN
Number('TT2') // NaN

Syntax: Number(string)

Summarize

This article ends here. I hope it can be helpful to you. I also hope you can pay more attention to more content on 123WORDPRESS.COM!