字符串方法

1.String.prototype.charAt

从一个字符串中返回指定的字符。
@param index {number} 可选字符的索引，默认为0
@return {string} 所在位置的字符，类型是字符串

var str = 'abcd';
var result = str.charAt();
console.log(result); // a
console.log(typeof result)  // 'string'

2. String.prototype.charCodeAt

返回字符在unicode编码中对应的整数
@param index {number} 可选字符的索引，默认为0
@return {number} 返回该索引位置字符的unicode编码，如果索引越界，则返回NaN

"ABC".charCodeAt(0) // returns 65:"A"
"ABC".charCodeAt(1) // returns 66:"B"
"ABC".charCodeAt(2) // returns 67:"C"
"ABC".charCodeAt(3) // returns NaN

3. String.fromCharCode

返回数字在unicode编码中对应的值（字母）
@param number {number} 数字
@return {string} 返回该索引位置字符数字的字母(unicode编码)

var result = String.fromCharCode('97');
console.log(result) // 'a'

4. String.prototype.concat

将一个或多个字符串与原字符串连接合并，形成一个新的字符串并返回。
@param stringN {string} 和原字符串连接的多个字符串
@return {string} 返回新的字符串

var str = 'abc';
var result = str.concat('efg');
console.log(result); // abcdefg
var result = str.concat("'efg'"); // abcd'efg'
console.log(result);

5. String.protoype.indexOf

返回在字符串中第一次出现的指定值的索引，从 fromIndex开始搜索。
@param searchValue {string} 一个字符串表示被查找的值。
@param fromIndex {number} 可选表示调用该方法的字符串中开始查找的位置。可以是任意整数。默认值为 0。
@param {number} 第一次找到指定值的索引，如果找不到指定值，返回-1

var str = 'abcdefg';
var result = str.indexOf('b');
console.log(result);
result = str.indexOf('h'); // 1
console.log(result); // -1

6. String.protoype.lastIndexOf

返回指定值在调用该方法的字符串中最后出现的位置，如果没找到则返回 -1。从该字符串的后面向前查找，从 fromIndex 处开始。
@param searchValue {stirng} 需要查找的值
@param fromIndex {number} 可选从调用该方法字符串的此位置处开始查找。可以是任意整数。默认值为 str.length。
@return {number} 第一次找到指定值的索引，如果找不到指定值，返回-1

var str = 'aaa';
var result = str.lastIndexOf('a');
console.log(result); // 2

7. String.prototype.localeCompare

返回一个数字来指示一个参考字符串是否在排序顺序前面或之后或与给定字符串相同。
@param compareString {string} 用来比较的字符串
@param locale 略
@param option 略
@return {number} 如果引用字符存在于比较字符之前则为负数; 如果比较字符存在于引用字符之后则为正数; 相等的时候返回 0 .

7.1 使用示例

// The letter "a" is before "c" yielding a negative value
'a'.localeCompare('c'); 
// -2 or -1 (or some other negative value)

// Alphabetically the word "check" comes after "against" yielding a positive value
'check'.localeCompare('against'); 
// 2 or 1 (or some other positive value)

// "a" and "a" are equivalent yielding a neutral value of zero
'a'.localeCompare('a'); 
// 0

也就是如果调用函数的字符串对象‘大于’比较的字符串，则返回正数

7.2 学生名字排序：

学生的名字保存在一个数组中，每个名字都是一个字符串
排序规则如下：

名字短的排前面
名字长度相同的，按Unicode编码升序排列

function sortName(names){
    names.sort(function(a, b){
        // 等长排序规则
        if(a.length === b.length){
            /**
                当a>b时，a.localeCompare返回正数，同号，sort为升序
            */
            return a.localeCompare(b);
        }
        // 不等长排序规则
        else{
            /**
                当a的长度大于b的长度时，a.length-b.length为正数，同号，sort为升序
            */
            return a.length - b.length;
        }
    });
}
var names = ['John', 'Tom', 'Jerry', 'Mike', 'Jane'];
sortName(names);
console.log(names); // ["Tom", "Jane", "John", "Mike", "Jerry"]

8. String.prototype.match

当一个字符串与一个正则表达式匹配时， match()方法检索匹配项。
@param regexp {regexp or otherObject} 一个正则表达式对象。如果传入一个非正则表达式对象，则会隐式地使用 new RegExp(obj) 将其转换为一个RegExp。如果你未提供任何参数，直接使用 match() ，那么你会得到一个包含空字符串的 Array：[""] 。
@return array {array} 如果字符串匹配到了表达式，会返回一个数组，数组的第一项是进行匹配完整的字符串，之后的项是用圆括号捕获的结果。如果没有匹配到，返回null

8.1 示例

var str = 'For more information, see Chapter 3.4.5.1';
var re = /see (chapter d+(.d)*)/i;
var found = str.match(re);

console.log(found);

// logs [ 'see Chapter 3.4.5.1',
//        'Chapter 3.4.5.1',
//        '.1',
//        index: 22,
//        input: 'For more information, see Chapter 3.4.5.1' ]

// 'see Chapter 3.4.5.1' 是整个匹配。
// 'Chapter 3.4.5.1' 被'(chapter d+(.d)*)'捕获。
// '.1' 是被'(.d)'捕获的最后一个值。
// 'index' 属性(22) 是整个匹配从零开始的索引。
// 'input' 属性是被解析的原始字符串。

可以发现：match返回的数组首先第一项是完整匹配后的字符串，而之后是re中较长的()匹配的字符串，再到较短一些的()匹配的字符串，直到没有()为止；最后给这个数组对象添加index和input两个属性

8.2 当参数为正则表达式

var str1 = "NaN means not a number. Infinity contains -Infinity and +Infinity in JavaScript.",
    str2 = "My grandfather is 65 years old and My grandmother is 63 years old.",
    str3 = "The contract was declared null and void.";
str1.match("number");   // "number" 是字符串。返回["number"]
str1.match(NaN);        // NaN的类型是number。返回["NaN"]
str1.match(Infinity);   // Infinity的类型是number。返回["Infinity"]
str1.match(+Infinity);  // 返回["Infinity"]
str1.match(-Infinity);  // 返回["-Infinity"]
str2.match(65);         // 返回["65"]
str2.match(+65);        // 有正号的number。返回["65"]
str3.match(null);       // 返回["null"]

9. String.prototype.replace

返回一个由替换值替换一些或所有匹配的模式后的新字符串。模式可以是一个字符串或者一个正则表达式, 替换值可以是一个字符串或者一个每次匹配都要调用的函数。原字符串不变
@param pattern {regexp or string} 匹配模式
- regexp {regexp}：正则表达式，根据表达式决定替换的个数
- substr {string}：需要被替换的字符串，仅仅替换第一个
@param replacement {string or function} 替换后的内容
- newSubstr {string}：将匹配到的字符串替换成该字符串
- function {function}：一个用来创建新子字符串的函数，该函数的返回值将替换掉第一个参数匹配到的结果。
  - @param matchValue {string} 每个调用函数的匹配结果
@return {number}：返回一个新的字符串

比较特殊的是，字符串实参可以使用下面的特殊变量名代替：

变量名	代表的值
`$$`	插入一个 "$"。
`$&`	插入匹配的子串。
`$``	插入当前匹配的子串左边的内容。
`$'`	插入当前匹配的子串右边的内容。
`$n`	假如第一个参数是RegExp对象，并且 n 是个小于100的非负整数，那么插入第 n 个括号匹配的字符串。

9.1 使用正则表达式替换

var str = 'Twas the night before Xmas...';
var newstr = str.replace(/xmas/i, 'Christmas');
console.log(newstr);  // Twas the night before Christmas...

9.2 使用字符串替换

var substr = 'abc';
var str = 'abcdefabc';
var newStr = str.replace(substr, 'g');
console.log(newStr); // gdefabc

9.3 使用特殊的变量名字符串替换

var re = /(w+)s(w+)/;
var str = "John Smith";
var newstr = str.replace(re, "$2, $1");
console.log(newstr); // Smith, John
// 先匹配到John和Smith两个结果
// 然后，在这些匹配结果中执行'$2, $1'：把匹配结果中第二个字符串插入到第一个位置，第一个字符串插入到第二个位置

9.4 使用函数替换

var str = 'abcdefg';
var pattern = /w/g;
var newStr = str.replace(pattern, function(matchValue){
    return String.fromCharCode(matchValue.charCodeAt() + 1);
});
console.log(newStr) // bcdefgh

10. String.prototype.slice

截取字符串
@param beginSlice {number} 可选开始截取的位置，默认为0。可以为负数，同endSlice
@param endSlice {number} 可选。结束截取的位置（不包括该位置）。默认为length。可是是负数，表示倒数第几个的位置，比如-1表示倒数第一个位置，即length-1
@return {string} 返回一个新的字符串

var str = 'abcdefg';
var result = str.slice();
console.log(result); // abcdefg
result = str.slice(1);
console.log(result); // bcdefg
result = str.slice(0, -2);
console.log(result); // abcde

11. String.prototype.split

使用指定的分隔符字符串将一个String对象分割成字符串数组，以将字符串分隔为子字符串，以确定每个拆分的位置。
@param separator {string} 分隔符
@param limit {number} 一个整数，限定返回的分割片段数量
@return {array} 返回一个字符串数组

var str = 'abcdefg';
var result = str.split('');
console.log(result); // ["a", "b", "c", "d", "e", "f", "g"]
result = str.split('d'); 
console.log(result); // ["abc", "efg"]

12. String.prototype.substr

截取一个字符串中从指定位置开始到指定字符数的字符。
@param start {number} 开始位置
@param length {length} 截取的长度
@return {string} 结果字符串

var str = 'abcdefg';
var result = str.substr(1, 2);
console.log(result); // 'bc'

13. String.prototype.substring

截取一个字符串在开始索引到结束索引之间的一个子集
@param start {number} 开始索引
@param end {number} 结束索引，不包括该位置
@return {string} 返回结果字符串

var str = 'abcdefg';
var result = str.substring(1, 3);
console.log(result); // 'bc'

14. String.prototype.toLowerCase

将字符串转换为小写
@return {string} 返回新的结果字符串

var str = 'ABCDEFG';
var result = str.toLowerCase();
console.log(result); // abcdefg

15. String.prototype.toUpperCase

将字符串转换为大写
@return {string} 返回新的结果字符串

var str = 'abcdefg';
var result = str.toLowerCase();
console.log(result); // ABCDEFG

16. String.prototype.toString

返回指定对象的字符串形式。
@return {string} 字符串对象的字符串值

var str = new String('abcdefg');
var result = str.toString();
console.log(result); // 'abcdefg'

17. String.prototype.valueOf

返回字符串的原始值，相当于String.prototype.toString
@return {string} 字符串对象的字符串值

var str = 'abcdefg';
var result = str.valueOf();
console.log(result); // 'abcdefg'

18. String.prototype.trim

删除字符串两端的空白
@return {string} 返回新的字符串

var str = ' a dc d ';
var result = str.trim();
console.log(result); // a dc d
console.log(result.length) // 6

19. String.prototype.trimLeft

删除字符串左端的空白
@return {string} 返回新的字符串

var str = ' a dc d ';
var result = str.trimLeft();
console.log(result); // a dc d
console.log(result.length) // 7
console.log(result[0]) // a

20. String.prototype.trimRight

删除字符串右端的空白
@return {string} 返回新的字符串

var str = ' a dc d ';
var result = str.trimRight();
console.log(result); // a dc d
console.log(result.length) // 7
console.log(result[result.length-1]) // d