字符串

发表于   |   分类于

字符串的属性

length

1
2
var str = "Hello world!"
str.length; // 12

字符串的方法

charAt() 和 charCodeAt()

语法：
strObj.charAt(index)

  • index：必需。表示字符串中某个位置的数字，即字符在字符串中的下标。
  • 返回值：String，返回该位置的字符。
1
2
var str = "Hello world!"
str.charAt(3); // 'l'

语法：
strObj.charCodeAt(index)

  • index 必需。表示字符串中某个位置的数字，即字符在字符串中的下标。
  • 返回值：Number，返回该位置字符的 Unicode 十进制编码。
1
2
var str = "Hello world!"
str.charCodeAt(3); // 108

字符是按顺序编码的：

  • 大写字母的编码是从 65 开始的，字母 A 的编码是 65，B 的编码是 66…
  • 小写字母是从 97 开始的，字母 a 的编码是 97，b 的编码是 98…
  • 数字的编码是从 48 开始的，0 对应的编码是 48，9 对应的编码是 57…

indexOf()和lastIndexOf()

语法：
strObj.indexOf(searchvalue, fromindex)

  • searchvalue 必需。规定需检索的字符串值。
  • fromindex 可选。整数参数，规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的首字符开始检索。
  • 返回值：Number, 子串在字符串中的位置，以 0 为基础
1
2
3
4
var str = "Hello, jeremy. How are you jeremy";

str.indexOf('jeremy'); // 7
str.indexOf('jeremy', 10); // 27

语法：
strObj.lastIndexOf(searchvalue, fromindex);

  • 语法同上，唯一的区别是 lastIndexOf() 从字符串的结尾或指定位置向开头查找。
1
2
str.lastIndexOf('jeremy'); // 27
str.lastIndexOf('jeremy',10 ); // 7

substr()、substring()和slice()

substr() 和 substring() 均用来提取一个子串，但它们需要的参数不同。

substr() （不建议使用）

语法：
strObj.substr(start, length);

  • start 必需。提取子串的起始下标。必须是数值。如果是负数，那么该参数声明从字符串的尾部开始算起的位置。也就是说，-1 指字符串中最后一个字符，-2 指倒数第二个字符，以此类推。
  • length 可选。子串中的字符数。必须是数值。如果省略了该参数，那么返回从起始下标到结尾的字串。
  • 返回值：String, 提取的子串
1
2
3
4
var str = "JavaScript";
str.substr(0,4); // "Java"
str.substr(-4,4); // "ript"
str.substr(4,4); // "ript"

参数 length 原则上不能为负数，若强行传递负数，会被当成 0 处理，那么该方法返回的就是一个空串（即长度为 0 的字符串）。

substring()

语法：
strObj.substring(start, stop)

  • start 必需。一个非负的整数，提取子串的起始下标。
  • stop 可选。一个非负的整数，提取子串的结束下标+1。如果省略该参数，那么返回的子串会一直到字符串的结尾。
  • 返回值： String, 提取的子串
1
str.substring(0,4); // "Java"

stop 的数值可以比 start 小，该情况与 str.substring(stop, start) 情况相同

1
str.substring(4,0); // "Java"

原则上参数不能为负数，若强行传负数，在执行时会被当成 0 处理。

1
2
3
str.substring(3,-1); // "Jav"
str.substring(-1,3); // "Jav"
str.substring(-1,-2); // ""
slice()

语法：
strObj.slice(start, end);

  • start 必需。必须是数值，提取子串的起始下标。如果是负数，那么该参数声明从字符串的尾部开始算起的位置。也就是说，-1 指字符串中最后一个字符，-2 指倒数第二个字符，以此类推。
  • end 可选。提取子串的结束下标+1。若未指定此参数，则要提取的子串包括 start 到原字符串结尾的字符串。如果该参数是负数，那么它规定的是从字符串的尾部开始算起的位置。
  • 返回值： String，一个新的字符串，值与提取的子串相同。

注：slice() 和 substring() 的区别在于 slice() 接受负数参数。

1
2
3
4
var str = "JavaScript";
str.slice(1,4); // "ava"
str.slice(-4,-1); // "rip"
str.slice(-1,-4); // ""

concat()

字符串的拼接

语法：
str.concat(string2[, string3, …, stringN])

1
2
3
var hello = 'Hello, ';
console.log(hello.concat('Kevin', '. Have a nice day.'));
// Hello, Kevin. Have a nice day.
1
2
3
4
5
6
7
8
9
10
11
12
13
var greetList = ['Hello', ' ', 'Venkat', '!'];
"".concat(greetList)
// "Hello, ,Venkat,!"

"".concat(...greetList);
// "Hello Venkat!"

"".concat({}); // [object Object]
"".concat([]); /// ""
"".concat(null); // "null"
"".concat(true); // "true"
"".concat(4, 5); // "45"
"".concat({}); // [object Object]

toUpperCase()和toLowerCase()

大小写转换

1
2
3
var str = "I Don't Care About Case";
str.toLowerCase(); // "i don't care about case"
str.toUpperCase(); // "I DON'T CARE ABOUT CASE"

split()

把一个字符串分割成数组，原字符串不会被改变。

语法：
str.split(separator, howmany)

  • separator 必需。字符串或正则表达式，从该参数指定的地方分割 str。
  • howmany 可选。该参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。
  • 返回值：String，分割后的数组。
1
2
3
4
5
var str1 = "a,1,b,2,c,3";
console.log(str1.split(",")); // ["a", "1", "b", "2", "c", "3"]

var str2 = "a,1,b,2,c,"; 
console.log(str2.split(",")); // ["a", "1", "b", "2", "c", ""]

注：每个分割符代表着数组中的一个元素，上述情况最后一个元素是空字符串

replace()

用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串，原字符串不会被改变。

语法：
str.replace(regexp/substr, replacement)

  • regexp/substr 必需。规定子字符串或 RegExp 对象
  • replacement 可选。替换文本，可以是字符串，也可以是函数
  • 返回值：String，替换文本后的字符串
1
2
3
4
5
var str3 = "This is an red apple.";
console.log(str3.replace('apple', 'strawberry')); // This is an red strawberry.
console.log(str3); // This is an red apple.

console.log(str3.replace(/\bis\b/g, 'AA')); // This AA an red apple.

注：如果正则表达式中具有全局标志 g，那么 replace() 方法将替换所有匹配的子串，否则只替换第一个匹配子串。

如果 replacement 为函数，则函数对应的参数：

1
2
3
str.replace(regexp, function(eachStr [, eachSubstr1, eachSubstr2 ...] [, eachStrIndex1, eachStrIndex2, ..] [, str]){
   // do something
})
  • eachStr 每个匹配的字符串
  • eachSubstr 每个匹配的子字符串(正则表达式中的小括号分组)
  • eachStrIndex 整数，每个匹配的字符串出现的位置
  • str 原字符串
  • 返回值：String, 被替换的字符串
1
2
3
4
5
6
console.log(str3.replace(/is/g, function(str){
  console.log(str); // is
  return str.toUpperCase();
})); 

// is, is, ThIS IS an red apple.
1
2
3
4
5
6
7
8
9
10
11
console.log(str3.replace(/(i)s/g, function(str, substr, index, originStr){
  console.log(str); // is
  console.log(substr); // i 
  console.log(index); // 2, 5
  console.log(originStr); // This is an red apple
  return str.toUpperCase();
})); 

// is, i, 2, This is an red apple.
// is, i, 5, This is an red apple.
// ThIS IS an red apple.

注：子字符串是指正则表达式中的小括号的分组内容

1
2
3
4
5
6
7
8
9
10
11
12
13
console.log(str3.replace(/(i)(s)/g, function(a,b,c,d,e,f){
  console.log(a); // is
  console.log(b); // i 
  console.log(c); // s 
  console.log(d); // 2, 5
  console.log(e); // This is an red apple
  console.log(f); // undefined
  return a.toUpperCase();
})); 

// is, i, s, 2, This is an red apple., undefined
// is, i, s, 5, This is an red apple., undefined
// ThIS IS an red apple.

参数个数是严格根据正则表达式来的，上例中只有两个分组，因此只有 b、c 两个参数用来匹配子字符串，而参数 f 因为没有对应的内容而显示 undefined。

replacement 中的 \$ 字符具有特定的含义。如下表所示，它说明从模式匹配得到的字符串将用于替换。

  • $1、$2、…、$99：与 regexp 中的第 1 到第 99 个子表达式相匹配的文本。
  • $&：与 regexp 相匹配的子串。
  • $`：位于匹配子串左侧的文本。
  • $’：位于匹配子串右侧的文本。
  • $$：$ 符号。
1
2
3
4
var str4 = 'abcd'
console.log(str4.replace(/(c)/g, "---$2 $1 $` $'---"));

// ab ---$2 c ab d--- d

其中，
$1: c
$2: undefined
$&: c
$`: ab
$’: d

检索子字符串，或与正则表达式相匹配的子字符串，原字符串不会被改变。

语法：
str.search(substr/regexp)

  • substr/regexp：子字符串或 RegExp 对象
  • 返回值：Number, 子字符串第一次出现的位置，如果不含该子字符串，则返回 -1
1
2
3
4
5
var str5 = "abcdecfCg";
console.log(str5.search('d')); // 3
console.log(str5) // abcdefg

console.log(str5.search(/c/g)); // 2

注：search() 方法不执行全局匹配，它将忽略标志 g

1
2
console.log(str5.search(/C/));  // 7
console.log(str5.search(/C/i)); // 2

match()

检索子字符串，或与正则表达式相匹配的子字符串。原字符串不会被改变

语法：
str.match(substr/regexp)

  • substr/regexp：子字符串或 RegExp 对象
  • 返回值：
    1. 如果参数是substr或regexp（非全局匹配），则返回数组：[subStr, groupStr_1, groupStr_2, … index, input]
      • subStr: 与表达式相匹配的字符串
      • groupStr_i: 与第 i 个子表达式相匹配的字符串
      • index: 匹配的字符串第一次出现的位置
      • input: 原字符串
    1. 如果参数是regexp（全局匹配），则返回一个包含所有匹配子串的数组（没有index属性或input属性）
1
2
3
4
5
6
7
8
9
var str6 = "abcdecfCg";
console.log(str6.match("c"));
// ["c", index: 2, input: "abcdecfCg"]

console.log(str6.match(/c/i));
// ["c", index: 2, input: "abcdecfCg"]

console.log(str6.match(/c/g));
// ["c", "c"]