MDN - 字符串API笔记

传送门

String.prototype.charAt(index)

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

index 一个介于0 和字符串长度减1之间的整数。默认值为0

index 从 0 开始 空格是占一个位置的

获取一个超出字符串长度的位置，则返回空格 不报错

var anyString = "Brave new world";
console.log(anyString.charAt(0)); // B

// 区别：通过字符串下标获取
console.log(anyString[1]); // B
console.log(anyString[100]); // undefined

String.prototype.charCodeAt(index)

返回字符串指定位置的字符编码

用于键盘事件

区分大小写的

index 超出位置 返回 NaN

空格的编码号 32

String.fromCharCode(unicode 编码)

把对应的编码还原字符串

var str = "I love you bady";
    var codeArr = [];
    for (var index in str) {
      codeArr.push(str.charCodeAt(index));
    }
    console.log(codeArr);
    var s = "";
    for (var index in codeArr) {
      s += String.fromCharCode(codeArr[index]);
    }
    console.log(s);

String.prototype.indexOf(searchValue [, fromIndex])

返回调用它的String 中第一次出现的指定值的索引，从 fromIndex 处进行搜索。如果未找到该值，则返回 -1

searchValue 要被查找的字符串值。如果没有提供确切地提供字符串，searchValue 会被强制设置为 “undefined” （会将传入的值转化成字符串）

fromIndex 数字表示开始查找的位置。可以是任意整数，默认值为 0。

'undefined'.indexOf(); // 0
'null'.indexOf(null); // 0

String.prototype.lastIndexOf(searchValue[, fromIndex])

返回调用 String 的指定值最后一次出现的索引，在一个字符串中的指定位置 fromIndex处从后向前搜索。如果没找到这个特定值则返回-1

searchValue 一个字符串，表示被查找的值。如果searchValue是空字符串，则返回fromIndex。

fromIndex 待匹配字符串从str的第fromIndex位开始向左回向查找

 'canal'.lastIndexOf('a');     // returns 3 （没有指明fromIndex则从末尾l处开始反向检索到的第一个a出现在l的后面，即index为3的位置）
  'canal'.lastIndexOf('a', 2);  // returns 1（指明fromIndex为2则从n处反向向回检索到其后面就是a，即index为1的位置）
  'canal'.lastIndexOf('a', 0);  // returns -1(指明fromIndex为0则从c处向左回向检索a发现没有，故返回-1)
  'canal'.lastIndexOf('x');     // returns -1
  'canal'.lastIndexOf('c', -5); // returns 0（指明fromIndex为-5则视同0，从c处向左回向查找发现自己就是，故返回0）
  'canal'.lastIndexOf('c', 0);  // returns 0（指明fromIndex为0则从c处向左回向查找c发现自己就是，故返回自己的索引0）
  'canal'.lastIndexOf('');      // returns 5
  'canal'.lastIndexOf('', 2);   // returns 2

String.prototype.concat(str2, [, ...strN])

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

str2 [, …strN] 需要连接到 str 的字符串。

var hello = 'Hello, '
console.log(hello.concat('Kevin', '. Have a nice day.')) // Hello, Kevin. Have a nice day.

String.prototype.split([separator[, limit]])

使用指定的分隔符字符串将一个String对象分割成子字符串数组，以一个指定的分割字串来决定每个拆分的位置

separator 指定表示每个拆分应发生的点的字符串。如果传递空字符串则拆分每个字母

limit 一个整数，限定返回的分割片段数量。

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

"hello world".split('l') // ["he","","o wor","d"]

"hello world".split('') // ["h","e","l","l","o"," ","w","o","r","l","d"]

补充：

 var str5 = "I ,wan,t to se,e the sun-raise with you";
 var newArr = str5.split(" ");
 console.log("split拆分==>", newArr)
 console.log("用split进行分割，会不会对原变量造成影响==>", str5)   // 不会

String.prototype.slice(beginIndex[, endIndex])

提取某个字符串的一部分，并返回一个新的字符串，且不会改动原字符串

beginIndex 从该索引（以 0 为基数）处开始提取原字符串中的字符。如果值为负数则倒数

endIndex 在该索引处结束前提取字符串**（不包含次索引处字符）**,如果省略该参数，slice() 会一直提取到字符串末尾。可以为负

var str6 = "用钱买开心,很开心!";
console.log("slice测试==>", str6.slice(1, 3)) // 钱买 （不包括索引3指向的“开”）
console.log("slice测试==>", str6.slice(4, 9)) // 心，,很开心（索引值超出长度的，不用被理会，不会报错）
console.log("slice测试==>", str6.slice(2, -4))// 买开心, 如果第二个参数是负数，那么它规定的是从数组尾部开始算起的元素
console.log("slice测试==>", str6.slice(-5, -2))// ,很开    负数， 倒数位数，倒数第5个开始到倒数第2个 输出数据
console.log("slice测试==>", str6.slice(2))    // 买开心,很开心!

注： 负数是从右到左开始，负多少，就先左数多少。（从一开始数）

String.prototype.substring(indexStart[, indexEnd])

返回一个字符串在开始索引到结束索引之间的一个子集, 或从开始索引直到字符串的末尾的一个子集。

indexStart 需要截取的第一个字符的索引，该索引位置的字符作为返回的字符串的首字母。

indexEnd 一个 0 到字符串长度之间的整数，以该数字为索引的字符不包含在截取的字符串内。若省略该属性substring 提取字符一直到字符串末尾。

注意：indexStart 和 indexEnd 数小于 0 或为 NaN，则被当作 0。

var anyString = "Mozilla";
// 输出 "Moz"
console.log(anyString.substring(0,3));
console.log(anyString.substring(3,0));
console.log(anyString.substring(3,-3));
console.log(anyString.substring(3,NaN));
console.log(anyString.substring(-2,3));
console.log(anyString.substring(NaN,3));

String.prototype.substr(start[, length])

返回一个字符串中从指定位置开始到指定字符数的字符。

start 开始提取字符的位置。如果为负值，则倒数

length 提取的字符数。

注意：该方法未来将要被舍弃请尽量避免使用该方法，使用substring替代它

var str = "abcdefghij";
console.log(str.substr(1,2));   // bc
console.log(str.substr(-3,2));  //  hi
console.log((str.substr(-3));    //  hij
console.log(str.substr(1));     //  bcdefghij
console.log(str.substr(-20,2)); //  ab
console.log(str.substr(20,2));  // 

String.prototype.replace(substr, newSubStr|function)

返回一个由替换值替换部分或所有的substr模式匹配项后的新字符串

substr 一个将被 newSubStr 替换的 字符串。

newSubStr 用于替换掉第一个参数在原字符串中的匹配部分的字符串。

function 一个用来创建新子字符串的函数，该函数的返回值将替换掉第一个参数匹配到的结果。

var re = "apples";
var str = "apples are round, and apples are juicy.";
var newstr = str.replace(re, "oranges"); // "oranges are round, and apples are juicy."

var re = "apples";
var str = "apples are round, and apples are juicy.";
// 给指定单词加引号
var newstr = str.replace(re, function(match) {
    // match 是匹配到的子串。
    return '"' + match + '"' 
}) // '"Apples" are round, and apples are juicy.'

String.prototype.replaceAll(substr, newSubstr|function)

一个新字符串，新字符串所有满足 pattern 的部分都已被replacement 替换

String.prototype.toLowerCase()

会将调用该方法的字符串值转为小写形式，并返回。

String.prototype.toUpperCase()

会将调用该方法的字符串转为大写形式并返回

String.prototype.repeat(count)

构造并返回一个新字符串，该字符串包含被连接在一起的指定数量的字符串的副本

count介于 0 和 +Infinity 之间的整数。表示在新构造的字符串中重复了多少遍原字符串。

"abc".repeat(-1)     // RangeError: repeat count must be positive and less than inifinity
"abc".repeat(0)      // ""
"abc".repeat(1)      // "abc"
"abc".repeat(2)      // "abcabc"
"abc".repeat(3.5)    // "abcabcabc" 参数count将会被自动转换成整数.
"abc".repeat(1/0)    // RangeError: repeat count 必须大于等于 0 且 小于+inifinity

String.prototype.trim()

会从一个字符串的两端删除空白字符。在这个上下文中的空白字符是所有的空白字符 (space, tab, no-break space 等)

var orig1 = '   foo  ';
console.log(orig1.trim()); // 'foo'

var orig2 = 'foo    ';
console.log(orig2.trim()); // 'foo'

ES6 的字符串方法

ES6学习笔记三:字符串

应用于正则表达式

String.prototype.match()

String.prototype.matchAll()

String.prototype.search()

String.prototype.toString()

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

var x = new String("Hello world");

alert(x.toString())      // 输出 "Hello world"

String.prototype.valueOf()

返回 String 对象的原始值

const stringObj = new String('foo');

console.log(stringObj);
// expected output: String { "foo" }

console.log(stringObj.valueOf());
// expected output: "foo"

String.prototype.localeCompare()

欢迎访问的我个人博客