String 的屬性和方法

屬性 length

字符串實例的 length 屬性返回字符串的長度。

let a = "aaaa";
a.length    // 4

跟數組不一樣的是，給 length 屬性賦值，不會改變原字符串的值。

方法

靜態方法

1. String.fromCharCode()

String.fromCharCode() 方法的參數是一個或多個數值，表明 Unicode 碼點，返回值是這些碼點組成的字符串。

String.fromCharCode();                            // ""
String.fromCharCode(97);                          // "a"
String.fromCharCode(104, 101, 108, 108, 111);     // "hello"

注意，該方法不支持 Unicode 碼點大於0xFFFF的字符，即傳入的參數不能大於0xFFFF（即十進制的 65535）。

2. String.fromCodePoint()

String.fromCodePoint() 方法也是將Unicode 碼點轉爲字符串，但能夠識別大於0xFFFF的字符，彌補了String.fromCharCode() 方法的不足。

String.fromCodePoint(0x20BB7)   // "𠮷"

該方法的做用，與 codePointAt() 方法相反。須要注意的是 fromCodePoint() 方法定義在 String 對象上，而 codePointAt() 方法定義在字符串的實例對象上。

實例方法

1. String.prototype.charAt()

charAt() 方法返回指定位置的字符，參數是從 0 開始編號的位置。

let s = 'abc'
s.charAt(1)               // "b"
s.charAt(s.length - 1)    // "c"

這個方法徹底能夠用數組下標替代。

'abc'.charAt(1)    // "b"
'abc'[1]           // "b"

若是參數爲負數，或大於等於字符串的長度，charAt 返回空字符串。

'abc'.charAt(-1)   // ""
'abc'.charAt(3)    // ""

2. indexOf() && lastIndexOf()

String.prototype.indexOf()

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

3. String.prototype.match()

可使用正則表達式

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

4. String.prototype.search()

search() 方法做用是尋找字符或子字符串在父字符串中的位置，返回下標，只能找到第一個符合條件的。沒有匹配的返回-1。

該方法支持正則表達式

'xaxb'.search('x')    // 0
'xaxb'.search(/x/)    // 0
'xaxb'.search(/x/g)   // 0

即便正則表達式帶有 g 修飾符，也只會返回第一個符合條件的。

5. includes() && startsWith() && endsWith()

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個位置直到字符串結束。

6. String.prototype.replace()

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

7. String.prototype.concat()

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"

8. String.prototype.slice()

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)     // ""

9. String.prototype.substring()

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。

10. String.prototype.substr()

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)    // ""

11. trim() && trimStart() && trimEnd()

該方法不改變原字符串

• 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, '');
  };
}

12. toLowerCase() && toUpperCase()

該方法不改變原字符串

toLowerCase() 方法用於將一個字符串所有轉爲小寫，toUpperCase() 則是所有轉爲大寫。它們都返回一個新字符串，不改變原字符串。

'Hello World'.toLowerCase()      // "hello world"
'Hello World'.toUpperCase()      // "HELLO WORLD"

13. String.prototype.split()

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', '*' ]

14. charCodeAt() && codePointAt()

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

15. String.prototype.repeat()

repeat() 方法返回一個新字符串，表示將原字符串重複n次。

'x'.repeat(3)       // "xxx"
'hello'.repeat(2)   // "hellohello"
'na'.repeat(0)      // ""

參數若是是小數，會被向下取整。

'na'.repeat(2.9)    // "nana"

若是參數是負數或者 Infinity，會報錯。參數NaN等同於 0。若是參數是字符串，則會先轉換成數字。

16. padStart() && padEnd()

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"

參考連接：
String 對象
字符串的新增方法