字符串實例的 length 屬性返回字符串的長度。javascript
let a = "aaaa"; a.length // 4
跟數組不一樣的是，給 length 屬性賦值，不會改變原字符串的值。html
String.fromCharCode() 方法的參數是一個或多個數值，表明 Unicode 碼點，返回值是這些碼點組成的字符串。java
String.fromCharCode(); // "" String.fromCharCode(97); // "a" String.fromCharCode(104, 101, 108, 108, 111); // "hello"
注意，該方法不支持 Unicode 碼點大於0xFFFF的字符，即傳入的參數不能大於0xFFFF（即十進制的 65535）。es6
String.fromCodePoint() 方法也是將Unicode 碼點轉爲字符串，但能夠識別大於0xFFFF的字符，彌補了String.fromCharCode() 方法的不足。正則表達式
String.fromCodePoint(0x20BB7) // "𠮷"
該方法的做用，與 codePointAt() 方法相反。須要注意的是 fromCodePoint() 方法定義在 String 對象上，而 codePointAt() 方法定義在字符串的實例對象上。數組
charAt() 方法返回指定位置的字符，參數是從 0 開始編號的位置。函數
let s = 'abc' s.charAt(1) // "b" s.charAt(s.length - 1) // "c"
這個方法徹底能夠用數組下標替代。測試
'abc'.charAt(1) // "b" 'abc'[1] // "b"
若是參數爲負數，或大於等於字符串的長度，charAt 返回空字符串。this
'abc'.charAt(-1) // "" 'abc'.charAt(3) // ""
String.prototype.indexOf()spa
indexOf() 方法用於肯定一個字符串在另外一個字符串中第一次出現的位置，返回結果是匹配開始的位置。若是返回-1，就表示不匹配。
'hello world'.indexOf('o') // 4
'JavaScript'.indexOf('script') // -1
indexOf(str,index) 方法還能夠接受第二個參數，表示從該下標位置開始向後匹配。
'hello world'.indexOf('o', 6) // 7
String.prototype.lastIndexOf()
lastIndexOf() 方法的用法跟 indexOf() 方法一致，主要的區別是 lastIndexOf 從尾部開始匹配，indexOf 則是從頭部開始匹配。
'hello world'.lastIndexOf('o') // 7
lastIndexOf(str,index) 的第二個參數表示從該位置起向前匹配。
'hello world'.lastIndexOf('o', 6) // 4
可使用正則表達式
match() 方法用於在父字符串中尋找匹配的子字符串，做爲類數組返回。若是沒有找到匹配，則返回 null。
可使用正則表達式，通常狀況下只要找到一個匹配的項，就中止尋找。且返回的數組含有 index 屬性和 input 屬性，分別表示匹配的子字符串開始的位置和原始字符串。
"accbbbcbba".match('bb') // ["bb", index: 3, input: "accbbbcbba"]
"accbbbcbba".match(/bb/) // ["bb", index: 3, input: "accbbbcbba"]
'abc'.match('d') // null
而若是正則表達式帶有 g 修飾符，則會一次性返回全部匹配成功的結果。且返回的數組不含有 index 屬性和 input 屬性。
'xaxb'.match(/a|b/) // ["a", index: 1, input: "xaxb"] 'xaxb'.match(/a|b/g) // ["a", "b"]
search() 方法做用是尋找字符或子字符串在父字符串中的位置，返回下標，只能找到第一個符合條件的。沒有匹配的返回-1。
該方法支持正則表達式
'xaxb'.search('x') // 0
'xaxb'.search(/x/) // 0
'xaxb'.search(/x/g) // 0
即便正則表達式帶有 g 修飾符，也只會返回第一個符合條件的。
ES6 提供了三種新方法，用來肯定一個字符串是否包含在另外一個字符串中。
String.prototype.includes()：返回布爾值，表示是否找到了參數字符串。String.prototype.startsWith()：返回布爾值，表示參數字符串是否在原字符串的頭部。String.prototype.endsWith()：返回布爾值，表示參數字符串是否在原字符串的尾部。let s = 'Hello world!';
s.startsWith('Hello') // true
s.endsWith('!') // true
s.includes('o') // true
這三個方法都支持第二個參數，表示開始搜索的位置。
s.startsWith('world', 6) // true
s.endsWith('Hello', 5) // true
s.includes('Hello', 6) // false
使用第二個參數 index 時，endsWith 的行爲與其餘兩個方法有所不一樣。它針對前 index 個字符，而其餘兩個方法針對從第index個位置直到字符串結束。
replace() 方法用於替換字符串，做爲一個新的字符串返回，不改變原字符串。接收兩個參數，第二個參數替換第一個參數匹配到的字符。
該方法不改變原字符串，且支持正則表達式
正常狀況只替換第一個匹配成功的值，只有在正則有 g 修飾符時，會替換全部匹配成功的值。
'aaa'.replace('a', 'b') // "baa"
'aaa'.replace(/a/, 'b') // "baa"
'aaa'.replace(/a/g, 'b') // "bbb"
參數
第一個參數能夠是字符串或正則表達式，第二個參數能夠是字符串或函數。
a. 當第二個參數爲字符串時，可使用 $ 符，來指代所替換的內容。
$&：匹配的子字符串。 $` ：匹配結果前面的文本。$'：匹配結果後面的文本。$n：匹配成功的第 n 組內容，n 是從 1 開始的天然數。$$：指代美圓符號 $。'hello world'.replace(/(\w+)\s(\w+)/, '$2 $1') // "world hello"
'abc'.replace('b', "[$`-$&-$']") // "a[a-b-c]c"
b. 當第二個參數爲函數時，必須有返回值，返回字符串。若是沒執行，會在匹配時執行。每匹配到一次正則，就執行一次函數，將每個匹配到的內容替換爲函數的返回值。
'3 and 5'.replace(/[0-9]+/g, function (match) {
return 2 * match;
})
// "6 and 10"
該函數能夠接受多個參數。第一個參數是匹配到的內容，第二個參數開始依次是匹配到的組內容（$1,$2...）。倒數第二個參數是匹配到的內容在整個字符串中的下標，最後一個參數是原字符串。
var prices = { 'p1': '$1.99', 'p2': '$9.99', 'p3': '$5.00' };
var template = '<span id="p1"></span>'
+ '<span id="p2"></span>'
+ '<span id="p3"></span>';
template.replace( /(<span id=")(.*?)(">)(<\/span>)/g,
function(match, $1, $2, $3, $4){
return $1 + $2 + $3 + prices[$2] + $4;
}
);
// "<span id="p1">$1.99</span><span id="p2">$9.99</span><span id="p3">$5.00</span>"
concat() 方法用於鏈接兩個字符串，返回一個新字符串，不改變原字符串。
該方法不改變原字符串
var s1 = 'abc'; var s2 = 'def'; s1.concat(s2) // "abcdef" s1 // "abc"
該方法能夠接受多個參數。
'a'.concat('b', 'c') // "abc"
若是參數不是字符串，concat() 方法會將其先轉爲字符串，而後再鏈接。
var one = 1; var two = 2; var three = '3'; ''.concat(one, two, three) // "123" one + two + three // "33"
slice(start, end) 方法用於從原字符串取出子字符串並返回，不改變原字符串。它的第一個參數是子字符串的開始位置，第二個參數是子字符串的結束位置（不含該位置）。
與數組的 slice() 方法同樣。
該方法不改變原字符串
參數
a. slice(start, end)，從下標 start 開始截取到下標 end 的元素，包含 start 不包含 end。
'JavaScript'.slice(0, 4) // "Java"
b. slice(start)，只有 start 一個參數表示從包含 start 的下標開始一直到原字符串結束。
'JavaScript'.slice(4) // "Script"
c. slice(-start, -end)，參數能夠用負數。表示倒數計算的位置。-1 表示倒數計算的第一個位置，依次向前類推。
'JavaScript'.slice(-6) // "Script" 'JavaScript'.slice(0, -6) // "Java" 'JavaScript'.slice(-2, -1) // "p"
d. 若是第一個參數大於等於字符串長度，或者第二個參數小於第一個參數，則返回一個空字符串。
'JavaScript'.slice(2, 1) // ""
substring(start, end) 方法用於從原字符串取出子字符串並返回，不改變原字符串。規則與 slice() 相似，不能用負數截取。
該方法不改變原字符串
參數
a. substring(start, end)，從下標 start 開始截取到下標 end 的元素，包含 start 不包含 end。
'JavaScript'.substring(0, 4) // "Java"
b. substring(start)，只有 start 一個參數表示從包含 start 的下標開始一直到原字符串結束。若是start 大於等於字符串長度，返回空字符串。
'JavaScript'.substring(4) // "Script" 'JavaScript'.substring(10) // ""
c. 第二個參數小於第一個參數，substring() 方法會自動更換兩個參數的位置。
'JavaScript'.substring(10, 4) // "Script"
d. 若是參數是負數，substring() 方法會自動將負數轉爲0。
'JavaScript'.substring(-3) // "JavaScript" 'JavaScript'.substring(4, -3) // "Java"
因爲這些規則違反直覺，所以不建議使用 substring() 方法，應該優先使用 slice。
substr(start,length) 方法用於從原字符串取出指定長度的子字符串並返回，不改變原字符串。第一個參數能夠是負數。-1 表明最後一個位置的值。
該方法不改變原字符串
參數
a. substr(start, length)，從下標 start 開始截取長度爲 length 的值。
'JavaScript'.substr(4, 6) // "Script"
b. substr(start)，只有 start 一個參數表示從包含 start 的下標開始一直到原字符串結束。若是start 大於等於字符串長度，返回空字符串。
'JavaScript'.substr(4) // "Script" 'JavaScript'.substr(10) // ""
c. 若是第一個參數是負數，表示倒數計算的字符位置。若是第二個參數是負數，將被自動轉爲0，所以會返回空字符串。
'JavaScript'.substr(-6) // "Script" 'JavaScript'.substr(4, -1) // ""
該方法不改變原字符串
String.prototype.trim() 用於去除字符串兩端的空格。String.prototype.trimStart() 消除字符串頭部的空格，保留尾部的空格。String.prototype.trimEnd() 消除字符串尾部的空格，保留頭部的空格。let s = ' hello world '; s.trim() // "hello world" s.trimStart() // "hello world " s.trimEnd() // " hello world"
該方法去除的不只是空格，還包括製表符（\t、\v）、換行符（\n）和回車符（\r）。
let s = '\r\nabc \t' s.trim() // 'abc' s.trimStart() // "abc \t" s.trimEnd() // "\r\nabc"
兼容處理
if (!String.prototype.trim) {
String.prototype.trim = function () {
return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
};
}
該方法不改變原字符串
toLowerCase() 方法用於將一個字符串所有轉爲小寫，toUpperCase() 則是所有轉爲大寫。它們都返回一個新字符串，不改變原字符串。
'Hello World'.toLowerCase() // "hello world" 'Hello World'.toUpperCase() // "HELLO WORLD"
split() 方法以字符串中的某一字符爲分隔符，拆分字符串，將分割出來的子字符串組成一個數組返回。數組中的每一項是字符串類型。
該方法不改變原字符串，且支持正則表達式
參數
a. split('') 分隔符爲空字符串，則返回數組的成員是原字符串的每個字符。
'a|b|c'.split('') // ["a", "|", "b", "|", "c"]
b. split() 省略參數，則返回數組的惟一成員就是原字符串。
'a|b|c'.split() // ["a|b|c"]
c. split('分隔符')
'a|b|c'.split('|') // ["a", "b", "c"]
'a||c'.split('|') // ['a', '', 'c']
'|b|c'.split('|') // ["", "b", "c"]
'a|b|'.split('|') // ["a", "b", ""]
d. split('分隔符',limit) 方法還能夠接受第二個參數，限定返回數組的最大成員數。
'a|b|c'.split('|', 1) // ["a"]
'a|b|c'.split('|', 2) // ["a", "b"]
e. split(/分隔符/,[limit])，
'aaa*a*'.split(/a*/) // [ '', '*', '*' ] "a b c".split(/\s+/) // ["a", "b", "c"]
若是正則表達式帶有括號，則括號匹配的部分也會做爲數組成員返回。
'aaa*a*'.split(/(a*)/) // [ '', 'aaa', '*', 'a', '*' ]
String.prototype.charCodeAt()
charCodeAt(index) 方法返回字符串指定位置的 Unicode 碼點（十進制表示），即 0 到 65535 之間的整數，至關於 String.fromCharCode() 的逆操做。
'abc'.charCodeAt(1) // 98 b的 Unicode 碼點是 98。
若是沒有任何參數，或不是一個數值，charCodeAt 返回首字符的 Unicode 碼點。
'abc'.charCodeAt() // 97
若是參數爲負數，或大於等於字符串的長度，charCodeAt 返回 NaN。
'abc'.charCodeAt(-1) // NaN 'abc'.charCodeAt(4) // NaN
不能正確返回 Unicode 碼點大於 0xFFFF 的字符。
String.prototype.codePointAt()
codePointAt() 方法，可以正確處理 4 個字節儲存的字符，返回一個字符的碼點。返回的是碼點的十進制值。若是想要十六進制的值，可使用toString()方法轉換一下。
let s = '𠮷a'; s.codePointAt(0).toString(16) // "20bb7" s.codePointAt(2).toString(16) // "61"
由於漢字「𠮷」須要4個字節儲存，對於這種4個字節的字符，JavaScript 不能正確處理，字符串長度會誤判爲2，所以可以使用 for...of 循環處理。
let s = '𠮷a';
for (let ch of s) {
console.log(ch.codePointAt(0).toString(16));
}
// 20bb7
// 61
codePointAt() 方法是測試一個字符由兩個字節仍是由四個字節組成的最簡單方法。
function is32Bit(c) {
return c.codePointAt(0) > 0xFFFF;
}
is32Bit("𠮷") // true
is32Bit("a") // false
repeat() 方法返回一個新字符串，表示將原字符串重複n次。
'x'.repeat(3) // "xxx" 'hello'.repeat(2) // "hellohello" 'na'.repeat(0) // ""
參數若是是小數，會被向下取整。
'na'.repeat(2.9) // "nana"
若是參數是負數或者 Infinity，會報錯。參數NaN等同於 0。若是參數是字符串，則會先轉換成數字。
ES2017 引入了字符串補全長度的功能。若是某個字符串不夠指定長度，會在頭部或尾部補全。padStart() 用於頭部補全，padEnd() 用於尾部補全。
padStart() 和 padEnd() 一共接受兩個參數，第一個參數是字符串補全生效的最大長度，第二個參數是用來補全的字符串。
'x'.padStart(4, 'ab') // 'abax' 'x'.padEnd(4, 'ab') // 'xaba'
若是原字符串的長度，等於或大於最大長度，則字符串補全不生效，返回原字符串。
'xxx'.padStart(2, 'ab') // 'xxx' 'xxx'.padEnd(2, 'ab') // 'xxx'
若是省略第二個參數，默認使用空格補全長度。
'x'.padStart(4) // ' x' 'x'.padEnd(4) // 'x '
用途
padStart() 的常見用途是爲數值補全指定位數。下面代碼生成 10 位的數值字符串。
'1'.padStart(10, '0') // "0000000001" '12'.padStart(10, '0') // "0000000012" '123456'.padStart(10, '0') // "0000123456"
另外一個用途是提示字符串格式
'12'.padStart(10, 'YYYY-MM-DD') // "YYYY-MM-12" '09-12'.padStart(10, 'YYYY-MM-DD') // "YYYY-09-12"