String - 《JavaScript 基础知识点》

语法
描述
String 实例
Api

String 全局对象是一个用于字符串或一个字符序列的构造函数

语法

字符串字面量

'string text'
"string text"

String 函数

使用 String 函数将其它值生成或转换为字符串

String(thing)
new string(thing)

thing 任何可以被转换成字符串的值

模板字面量（es6）

`hello world`
`hello ${who}`

长字符串

将长字符串写成多行

一：使用 + 运算符将多个字符串连接起来

let longString = "This is a very long string which needs" +
                                 "to wrap across multiple lines because" +
                 "otherwise my code is unreadable.";

二：在每行末尾使用反斜杠字符（‘\’），确保反斜杠后面没有空格、字符或缩进。

let longString = "This is a very long string which needs \
to wrap across multiple lines because \
otherwise my code is unreadable.";

两种方式会创建相同的字符串。

描述

字符串对于保存以文本形式的数据非常有用。

String 实例

Api

chatAt()

从一个字符串中返回指定索引的字符。

str.charAt(index)

charCodeAt()

返回给定索引处字符的 UTF-16 代码单元值的数字。如索引超出范围，则返回 NaN.

str.charCodeAt(index)

codePointAt()

返回一个Unicaode 编码点的非负整数

str.codePointAt(pos);  // pos 这个字符串需要转码的元素的位置

concat()

将一个或多个字符串与原字符串连接合并，形成一个新的字符串并返回。

str.concat(string2, string3[, ..., stringN])
let hello = 'Hello, ';
hello.concat('kevin', ' have a nice day'); // Hello, kevin have a nice day

由于性能问题，强烈建议赋值操作符（+， +=）代替concat 方法。

endsWith()

判断当前字符串是否以另一个给定字符串结尾。返回Boolean

str.endsWidth(searhString [, position]) 
// searchString 搜索字符串， position str的长度）， 默认 str.length 
var str = "To be, or not to be, that is the question.";
str.endWith('question.') // true
str.endsWith('to be')  // false
str.endsWith('to be', 19) // true

includes()

判断一个字符串是否包含在另一个字符串中，返回 boolean

// searchString  在 此字符串中搜索的字符串， 
// position 从当前字符串的那个索引位置开始搜寻子字符串，默认0
str.includes(searchString[, position])

includes 区分大小写

'Blue Whale'.includes('blue') // return false
let str = "To be, or not to be, that is the question.";
str.includes('To be') // true
str.includes('question') // true
str.includes('noonexistent') // false
str.includes('To be', 1); // false
str.includes('TO BE'); false

indexOf()

返回调用 String 对象中第一次出现的指定值的索引，在 fromIndex 开始进行搜索。
未找到就返回 -1.

// fromIndex < 0 (如传 0)； fromIndex >= str.length, 则返回 -1
str.indexOf(searchValue[, fromIndex])
let strs = "Blue Whale";
strs.indexOf('Blue') // return 0
strs.indexOf("Blute") // return -1
strs.indexOf("Whale", 5) // return 5
strs.indexOf("", 9) // return 9
strs.indexOf("", 10) // return 10
strs.indexOf("", 11) // return 10

区分大小写

被查找的字符串是一个空字符串， fromIndex < 0 时返回0，
0 < fromIndex < str.length 时返回 fromIndex
fronIndex > str.length 时返回 str.length

lastIndexOf()

返回指定值在字符串中最后出现的位置，如果没有则返回 -1.

// fromIndex 默认是 str.length; 负值 则被看作是0; 
// fromIndex > str.length 则 fromIndex 被看作是 str.length
str.lastIndexOf(searchValue[, fromIndex])

区分小大写

localCompare()

返回一个数字来指示一个参考字符串是否在排序前面或之后或与给定字符串相同。

'a'.localeCompare('c') //  -1
'check'.localeCompare('against') // 1
'a'.localCompare('a') // 0

match()

检索返回一个字符串匹配正则表达式的结果。

str.match(regexp)

regexp 一个正则表达式对象，如果传入非正则表达式对象，则会隐式地使用new RegExp(obj) 将其转换为一个 RegExp.如果你没有给出任何参数并直接使用match() ，你将会得到一个包含空字符的Array: [“”]

let str = 'For more information, see Chapter 3.4.5.1'
let re = /see (chapter \d+(\.\d)*)/i
let found = str.match(re)
["see Chapter 3.4.5.1", 
"Chapter 3.4.5.1", 
".1", 
index: 22, 
input: "For more information, 
see Chapter 3.4.5.1", 
groups: undefined]

match 使用全局和忽略大小写标志

let str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
let regexp = /[A-E]/gi;
let matches_array = str.match(regexp)
//  ["A", "B", "C", "D", "E", "a", "b", "c", "d", "e"]

padEnd()

str.padEnd(targetLength [, padString])
// targetLength 当前字符串需要填充到目标长度。 小于当前字符串的长度，则返回当前字符串
// padString 填充字符串，超过目标长度，则只保留最左侧部分。

返回值：
在原字符串末尾填充指定的填充字符串直到达到目标长度的新新字符串。

'abc'.pandEnd(10) // "abc       "
'abc'.padEnd(10, 'foo') // "abcfoofoof"
'abc'.padEnd(6, '123456') // 'abc123'
'abc'.padEnd(1) // 'abc'

padStart()

str.padStart(targetLength [, padString])

返回值：
在原字符串开头填充指定的填充字符串直到目标长度所形成的新字符串。

'abc'.padStart(10)  // "       abc"
'abc'.padStart(10, 'foo')  // "foofoofoofabc"
'abc'.padStart(6, '123456') // '123abc'
'abc'.padStart(8, '0')  // '00000abc'
'abc'.padStart(1) // 'abc'

repeat()

let resultString = str.repeat(count)
'abc'.repeat(-1)    // 报错
'abc'.repeat(1) // abc
'abc'.repeat(2) // abcabc
'abc'.repeat(3.5) // abcabcabc
'abc'.repeat(1 / 0) // 报错

replace()

原字符串不会改变

str.replace(regexp|substr, newSubStr|function)

在 replace() 中使用正则表达式

let str = 'Twas the night before Xmas...'
let newStr = str.replace(/xmas/i, 'Christmas')
console.log(newStr) // Twas the nigth before Christmas...
let re = /apple/gi
let str = "Apples are round, and apples are juicy."
let newStr2 = str.replace(re, 'orange')
console.log(newStr2) // "orange are round, and orange are juicy."

交换字符串中的两个单词

let re = /(\w+)\s(\w+)/
let str = "John Smith"
let newStr = str.replace(re, '$2, $1')
console.log(newStr) // Smith John

search()

str.search(regexp)

regexp 正则表达式对象，如果非正则表达式对象，会使用new RegExp(obj) 隐式地将其转换位正则表达式对象。

返回值：
匹配成功，则 search() 返回正则表达式在字符串中首次匹配项中的索引。否则，返回 -1

split()

str.split([separator[, limit]])

如果空字符（’’）被用作分隔符，则字符串会在每个字符串之间分割。
separator 可以是一个字符串或正则表达式
limit 一个帧数，限定返回的分割片断。

返回值
返回源字符串以分隔符出现位置分隔而成的一个数组。
当字符串为空，split() 返回一个包含一个空字符串的数组。

let str = ''
str.split() // ['']

移除字符串空格

let names = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand ";
let namesList1 = names.split(';')
// ["Harry Trump ", "Fred Barney", " Helen Rigby ", " Bill Abel ", "Chris Hand "]
let re = /\s(?:;|$)\s*/
let namesList2 = names.split(re) 
// ["Harry Trump", "Fred Barney", "Helen Rigby", "Bill Abel", "Chris Hand", ""]

限制返回值中分割元素数量

let myString = "Hello World. How are you doing?";
let splits = myString.split(" ", 3);
console.log(splits); //  ["Hello", "World.", "How"]

捕获括号

let myStringx = "Hello 1 word. Sentence number 2.";
let splitsx = myStringx.split(/(\d)/);
console.log(splitsx); // ["Hello ", "1", " word. Sentence number ", "2", "."]

startsWith()

str.startsWith(searchString [, position])

searchString 要搜索的子字符串
position str 中开始搜索 searchString 的开始位置，默认值 0

let str = 'To be, or not to be, that is the question.';
str.startsWitch("To be") // true
str.startsWitch("not to be") // false
str.startsWitch('not to be', 10) // true

sbustring()

str.substring(indexStart[, indexEnd])

包左不包右
indexStart > indexEnd 智能调换
任一参数小于 0 或为NaN ，则这一参数为 0
任一参数大于 string.length , 则被当作 string.length

var anyString = "Mozilla";
// Moz
console.log(anyString.substring(3,-3));
console.log(anyString.substring(3,NaN));
console.log(anyString.substring(-2,3));
console.log(anyString.substring(NaN,3));
//Mozill
console.log(anyString.substring(0,6));
// Mozilla
console.log(anyString.substring(0,10));
console.log(anyString.substring(10,0));
// 空
console.log(anyString.substring(0,0));

toLocaleLowerCase()

'ALPHABET'.toLocaleLowerCase() // 'alphabet'
'中文简体 zh-CN || zh-Hans'.toLocaleLowerCase() // '中文简体 zh-cn || zh-hans'

toLocaleUpperCase()

'alphabet'.toLocaleUppercase(); // 'ALPHABET'

toLowerCase()

'ALPHABET'.toLowerCase() // 'alphabet'
'中文简体 zh-CN || zh-Hans'.toLowerCase() // '中文简体 zh-cn || zh-hans'

toUpperCase()

'alphabet'.toUpperCase() // ALPHABET

toString()

str.toString()

返回指定对象的字符串形式

let x = new String('Hello world')
console.log(x.toString()) // Hello world

trim()

从一个字符串的两端删除空白字符；不影响原字符串本身，它返回一个新的字符串。

let orig = '   foo  '
let newstr = orig.trim(); // 'foo'
let orig = '   foo'
let newstr2 = orig.trim(); // 'foo'

trimRight()

从一个字符串的右端移除空白字符

let str = "   foo   "
let newStr = str.trimRight() // "   foo"

trimStart()

从字符串的开头删除空格

let str = "   foo   "
let newstr = str.trimStart() // "foo   "

valueOf()

返回String 对象的原始值

let x = new String('Hello world')
let strx = x.valueOf()  // "Hello world"