关于字符串方法总结

@(JavaScript基础)[String.prototype]

关于字符串方法总结

String.prototype

属性:

String.prototype.constructor
String.prototype.length

方法：

//  以下两种方法几乎没什么用
----------------------------------------------------------------------------
String.prototype.toString():
    描述:
        返回用字符串表示的特定对象,和 String.prototype.valueOf() 方法返回值一样
String.prototype.valueOf():
    描述:
        返回特定对象的原始值,该值等同于String.prototype.toString()
----------------------------------------------------------------------------


String.prototype[@@iterator]()
    描述:
        返回一个新的Iterator对象，它遍历字符串的代码点，返回每一个代码点的字符串值
    例子:
        let str='hello world';
        let newStr=str[Symbol.iterator]();
        console.log(newStr.next().value);  // 'h'
        console.log(newStr.next().value);  // 'e'
----------------------------------------------------------------------------

字符串的方法基本上可以分为增删改查

查找：

//  以下方法会返回该字符串是否存在某特定字符串的boolean值
----------------------------------------------------------------------------    
String.prototype.includes(searchString[, position]): (ES6)
    参数:
        searchString:
            要被搜索的字符串,区分大小写
        position:
            从当前字符串的哪个索引位置开始搜索字符串，默认值为0
    返回值:
        boolean值
----------------------------------------------------------------------------
String.prototype.startsWith(searchString [, position]):
    描述:
        判断字符串的起始位置是否匹配其他字符串中的字符
    参数:
        searchString:
            要搜索的子字符串
        position:
            要搜索字符串的位置，默认值为0
    返回值:
        boolean值
    例子:
        "hello world".startsWith("hello");  // true
        "hello world".startsWith("world");  // false
        "hello world".startsWith("world",6); // true
----------------------------------------------------------------------------
String.prototype.endsWith(searchString [, position]):
    描述:
        判断一个字符串的结尾是否包含其他字符串中的字符
    参数:
        searchString:
            要被搜索的字符串,区分大小写
        position:
            searchString 的结束位置，默认值为 str.length
    返回值:
        boolean值
    例子:
        "abccd".endsWith("d")     //true
        "abccd".endsWith("cd",0)  //false
        "abccd".endsWith("cd",1)  //false
        "abccd".endsWith("cd",2)  //false
        "abccd".endsWith("cd",3)  //false
        "abccd".endsWith("cd",4)  //false
        "abccd".endsWith("cd",5)  //false
----------------------------------------------------------------------------

//  以下方法返回特定位置的字符或字符码
----------------------------------------------------------------------------
String.prototype.charAt(index):
    参数:
        index
    返回值:
        返回特定位置的字符
----------------------------------------------------------------------------    
String.prototype.charCodeAt(index):
    参数:
        index
    返回值:
        返回表示给定索引的字符的 UTF-16 代码单元值的数字,如果索引超出范围，则返回 NaN
    例子:
        "ABC".charCodeAt(0) // returns 65
----------------------------------------------------------------------------
String.prototype.codePointAt(pos):
    参数:
        pos:
            这个字符串中需要转码的元素的位置
    返回值:
        返回使用UTF-16编码的给定位置的值的非负整数。
    例子:
        'ABC'.codePointAt(1);          // 66
        '\uD800\uDC00'.codePointAt(0); // 65536
----------------------------------------------------------------------------

//  以下方法返回特定字符串所在的索引
----------------------------------------------------------------------------    
String.prototype.indexOf(searchValue[, fromIndex]):
    描述:
        从字符串对象中返回首个被发现的给定值的索引值，如果没有找到则返回-1
    参数:
        searchString:
            要被搜索的字符串,区分大小写
        fromIndex:
            开始查找的位置，默认值为0
    返回值:
        指定值的第一次出现的索引; 如果没有找到 -1
----------------------------------------------------------------------------    
String.prototype.lastIndexOf(searchValue[, fromIndex]):
    描述:
        从字符串对象中返回最后一个被发现的给定值的索引值，如果没有找到则返回-1
    参数:
        searchString:
            要被搜索的字符串,区分大小写
        fromIndex:
            开始查找的位置，默认值为str.length
    返回值:
        指定值的第一次出现的索引; 如果没有找到 -1
    例子:
        "abcredfeefe".lastIndexOf("f")    // 9
        "abcredfeefe".lastIndexOf("f",9)  // 9
        "abcredfeefe".lastIndexOf("f",8)  // 6
        "abcredfeefe".lastIndexOf("f",6)  // 6
        "abcredfeefe".lastIndexOf("f",5)  // -1
----------------------------------------------------------------------------
String.prototype.search(regexp):
    描述:
        对正则表达式和指定字符串进行匹配搜索，返回第一个出现的匹配项的下标
    参数:
        regexp:
            一个正则表达式（regular expression）对象
    返回值:
        返回正则表达式在字符串中首次匹配项的索引
    例子:
        let reg=/ab/gi;
        "wabreabr".search(reg);    // 1
----------------------------------------------------------------------------

//  以下方法会返回符合查找结果的字符串组成的数组
----------------------------------------------------------------------------
String.prototype.split([separator[, limit]]):
    描述:
        通过分离字符串成字串，将字符串对象分割成字符串数组
    参数:
        separator:
            指定表示每个拆分应发生的点的字符串。separator 可以是一个字符串或正则表达式
            如果在str中省略或不出现分隔符，则返回的数组包含一个由整个字符串组成的元素
            如果分隔符为空字符串，则将str原字符串中每个字符的数组形式返回
        limit:
            限定返回的分割片段数量
    返回值:
        由分割字符串分割出来的字符串组成的数组
    例子:
        "abcd".split(); // ["abcd"]
        "abcd".split(); // ["a", "b", "c", "d"]
        "ab ba be eb".split(" ");     // ["ab", "ba", "be", "eb"]
        "ab ba be eb".split("b");     // ["a", " ", "a ", "e e", ""]
        "ab ba be eb".split(/b/gi);   // ["a", " ", "a ", "e e", ""]
        "ab ba be eb".split(/b/g);    // ["a", " ", "a ", "e e", ""]
----------------------------------------------------------------------------
String.prototype.match(regexp)
    描述:
        如果正则表达式没有 g 标志，则 str.match() 会返回和 RegExp.exec() 相同的结果。
        而且返回的 Array 拥有一个额外的 input 属性，该属性包含被解析的原始字符串。
        另外，还拥有一个 index 属性，该属性表示匹配结果在原字符串中的索引（以0开始）。

        如果正则表达式包含 g 标志，则该方法返回一个 Array，它包含所有匹配的子字符串而不是匹配对象。
        捕获组不会被返回(即不返回index属性和input属性)。如果没有匹配到，则返回  null
    参数:
        regexp:
            一个正则表达式对象。
            如果传入一个非正则表达式对象，则会隐式地使用 new RegExp(obj) 将其转换为一个 RegExp 。
            如果你未提供任何参数，直接使用 match() ，那么你会得到一个包含空字符串的 Array ：[""]
    返回值:
        由正则匹配到的字符串组成的数组
    例子:
        "abcdabeabeabiiiabeeaabbabb".match();    // 无参数  
        // ["", index: 0, input: "abcdabeabeabiiiabeeaabbabb"]
        "abcdabeabeabiiiabeeaabbabb".match("ab");    // 非RegExp对象
        // ["ab", index: 0, input: "abcdabeabeabiiiabeeaabbabb"]
        const rep=/ab/;
        "abcdabeabeabiiiabeeaabbabb".match(rep);   // 非g
        // ["ab", index: 0, input: "abcdabeabeabiiiabeeaabbabb"]
        "bcdabeabeabiiiabeeaabbabb".match(rep);
        // ["ab", index: 3, input: "bcdabeabeabiiiabeeaabbabb"]
        const repg=/ab/g;
        "abcdabeabeabiiiabeeaabbabb".match(repg);  
        // ["ab", "ab", "ab", "ab", "ab", "ab", "ab"]
----------------------------------------------------------------------------

增加:

//  增加单个字符串值
----------------------------------------------------------------------------
String.prototype.padStart(targetLength [, padString])
    描述:
        在当前字符串首部填充指定的字符串， 直到达到指定的长度。 返回一个新的字符串
    参数:
        targetLength:
            当前字符串需要填充到的目标长度
        padString:
            填充字符串
    返回值:
        在原字符串首部填充指定的填充字符串直到目标长度所形成的新字符串
    例子:
        "abc".padStart(10);  // "       abc"
        "abc".padStart(10,"foo");  // "foofoofabc"
        "abc".padStart(10,"foobarbaz");  // "foobarbabc"
        "abc".padStart(2);  // "abc"
----------------------------------------------------------------------------
String.prototype.padEnd(targetLength [, padString])
    描述:
        在当前字符串尾部填充指定的字符串， 直到达到指定的长度。 返回一个新的字符串
    参数:
        targetLength:
            当前字符串需要填充到的目标长度
        padString:
            填充字符串
    返回值:
        在原字符串末尾填充指定的填充字符串直到目标长度所形成的新字符串
    例子:
        "abc".padEnd(10);  // "abc       "
        "abc".padEnd(10,"foo");  // "abcfoofoof"
        "abc".padEnd(10,"foo");  // "abcfo"
        "abc".padEnd(2);  // "abc"
----------------------------------------------------------------------------
String.prototype.repeat(count)
    描述:
        返回指定重复次数的由元素组成的字符串对象
    参数:
        count:
            介于0和正无穷大之间的整数
    返回值:
        包含指定字符串的指定数量副本的新字符串
    例子:
        "ab".repeat(0)    // ""
        "ab".repeat(2)    // "abab"
        "ab".repeat(0)    // Uncaught RangeError: Invalid count value
        "ab".repeat(3.5)  // "ababab"

//  合并字符串
----------------------------------------------------------------------------
String.prototype.concat(string2, string3[, ..., stringN]):
    参数:
        string:
            要和原字符串拼接的字符串
    返回值:
        返回一个新的字符串
----------------------------------------------------------------------------

编辑:

//  以下方法转换大小写
----------------------------------------------------------------------------
String.prototype.toLocaleLowerCase():
    描述:
        根据当前区域设置，将符串中的字符转换成小写。对于大多数语言来说，toLowerCase的返回值是一致的
    
String.prototype.toLocaleUpperCase():
    描述:
        根据当前区域设置，将字符串中的字符转换成大写，对于大多数语言来说，toUpperCase的返回值是一致的
String.prototype.toLowerCase():
    描述:
        将字符串转换成小写并返回
String.prototype.toUpperCase():
    描述:
        将字符串转换成大写并返回
----------------------------------------------------------------------------

//  截取字符串
----------------------------------------------------------------------------
String.prototype.slice(beginSlice[, endSlice]):
    描述:
        摘取一个字符串区域，返回一个新的字符串。
    参数:
        beginSlice:
        endSlice:
            该endSlice位置的字符无法取到
    返回值:
        返回一个新的字符串,不会影响原字符串
    例子:
        let str="hello world";
        let newStr=str.slice(0,8);
        console.log(str);    // hello world
        console.log(newStr);   // hello wo
----------------------------------------------------------------------------
String.prototype.substr(start[, length]):
    描述:
        通过指定字符数返回在指定位置开始的字符串中的字符。
    参数:
        start:
            开始提取字符的位置
        length:
            提取的字符数
    返回值:
        返回一个字符串中从指定位置开始到指定字符数的字符
    例子:
        'hello world'.substr();    // 'hello world'
        'hello world'.substr(3);   // 'lo world'  
        'hello world'.substr(2,5); // 'llo w'
        
----------------------------------------------------------------------------
String.prototype.substring(indexStart[, indexEnd]):
    描述:
        返回在字符串中指定两个下标之间的字符
    参数:
        indexStart:
            起始位置
        indexEnd:
            结束位置，该位置的字符串无法取到
    返回值:
        返回在字符串中指定两个下标之间的字符
    例子:
        "hello world".substring(2,8);  // "llo wo"
        "hello world".substring(2);  // "llo world"
----------------------------------------------------------------------------
总结:
    String.prototype.slice和String.prototype.substring方法截取特定两个位置之间的字符串，且结束位置的字符无法取到
    String.prototype.substr方法截取从某特定位置开始，长度一定的字符串

//  替换
----------------------------------------------------------------------------
String.prototype.replace(regexp|substr, newSubStr|function):
    描述:
        被用来在正则表达式和字符串直接比较，然后用新的子串来替换被匹配的子串
    参数:
        regexp (pattern):
            一个RegExp 对象或者其字面量
        substr (pattern):
            一个要被 newSubStr 替换的字符串
        newSubStr (replacement):
            用于替换掉第一个参数在原字符串中的匹配部分的字符串
        function (replacement):
            一个用来创建新子字符串的函数，该函数的返回值将替换掉第一个参数匹配到的结果
    返回值:
        一个部分或全部匹配由替代模式所取代的新的字符串,不改变调用它的字符串本身
    例子:
        let rep=/ab/gi;
        "qabwabeabrr".replace(rep,"oo");    // "qoowooeoorr"
        "qabwabeabrr".replace("ab","oo");    // "qoowooeoorr"
        const bar=( )=>{return "oo"}
        "qabwabeabrr".replace(rep,bar);   // "qoowooeoorr"
        "qabwabeabrr".replace("ab",bar);   // "qoowooeoorr"
----------------------------------------------------------------------------

删除:

//  删除起止位置处的空格
----------------------------------------------------------------------------
String.prototype.trim():
    描述:
        从字符串的开始和结尾去除空格
String.prototype.trimLeft():
    描述:
        从字符串的左侧去除空格
String.prototype.trimRight():
    描述:
        从字符串的右侧去除空格
----------------------------------------------------------------------------

以下方法中会修改原字符串，返回新字符串：

String.prototype.toUpperCase
String.prototype.toLowerCase
String.prototype.toLocaleLowerCase
String.prototype.toLocaleUpperCase

String.prototype.trim
String.prototype.trimLeft
String.prototype.trimRight

以下方法中不会修改原字符串，返回新字符串：

String.prototype.padStart
String.prototype.padEnd
String.prototype.repeat
String.prototype.concat

String.prototype.sublice
String.prototype.substr
String.prototype.substring

String.prototype.replace