charAt()

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

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

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

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

1
2
3
4
5
6
var anyString = "Brave new world";
console.log(anyString.charAt(0)); // B

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

charCodeAt()

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

用于键盘事件

区分大小写的

index 超出位置 返回 NaN

空格的编码号 32

fromCharCode()

把对应的编码还原字符串

1
2
3
4
5
6
7
8
9
10
11
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);

indexOf()

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

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

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

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

lastIndexOf()

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

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

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

1
2
3
4
5
6
7
8
'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

concat()

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

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

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

split()

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

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

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

1
2
3
4
5
6
7
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"]

补充:

1
2
3
4
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) // 不会

slice()

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

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

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

1
2
3
4
5
6
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)) // 买开心,很开心!

注: 负数是从右到左开始,负多少,就先左数多少。(从一开始数)

substring()

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

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

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

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

1
2
3
4
5
6
7
8
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));

substr()

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

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

length 提取的字符数

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

1
2
3
4
5
6
7
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)); //

replace()

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
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.'

replaceAll()

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

toLowerCase()

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

toUpperCase()

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

repeat(count)

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

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

1
2
3
4
5
6
"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

trim()

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

1
2
3
4
5
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()

toString()

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

1
2
3
var x = new String("Hello world");

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

valueOf()

返回 String 对象的原始值

1
2
3
4
5
6
7
const stringObj = new String('foo');

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

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

String.prototype.localeCompare()