String原型方法

发表于 | 更新于: | 分类于
字数统计: 2,613 字 | 阅读时长 ≈ 12 分钟

String

String全局对象是一个用于字符串或一个字符序列的构造函数.

概述

除 Object 以外的所有类型都是不可变的(值本身无法被改变). JavaScript 中字符串是不可变的「JavaScript 中对字符串的操作一定返回了一个新字符串, 原始字符串并没有被改变」.

字符串字面量(通过单引号或双引号定义)和直接调用 String 方法(没有通过 new 生成字符串对象实例)的字符串都是基本字符串. JavaScript 会自动将基本字符串转换为字符串对象, 只有将基本字符串转化为字符串对象之后才可以使用字符串对象的方法.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
let a = 'Hello, World';
let b = String('Hello, World');
let c = new String('Hello, World');

console.log('a', a);
console.log('b', b);
console.log('c', c);

// a Hello, World
// b Hello, World
/* c String ={ 0: "H", 1: "e",2: "l",
              3: "l", 4: "o", 5: ",",
              6: " ", 7: "W", 8: "o", 9:
              r", 10: "l", 11: "d", length: 12 } */
// 可以看到String构造出来的是一个类数组, 这样就可以通过.或[]来取值.

当基本字符串需要调用一个字符串对象才有的方法或者查询值的时候(基本字符串是没有这些方法的「原始值」)，JavaScript 会自动将基本字符串转化为字符串对象并且调用相应的方法或者执行查询「JavaScript会自动将字符串字面值转换为一个临时字符串对象，调用该方法，然后废弃掉那个临时的字符串对象」.

原型方法(部分)

String.prototype.charAt()

描述 :
从一个字符串中返回指定索引位置的字符.
语法 :

str.charAt(index)

index(可选) : 介于 0 ~ (str.length - 1) 的整数. 若无, 默认值为 0. 超过指定范围数值, 则返回空字符串.

1
2
3
4
5
6
7
8
9
10
var anyString = "Hello World";
console.log("The character at index 0   is '" + anyString.charAt()   + "'");
console.log("The character at index 1   is '" + anyString.charAt(1)   + "'");
console.log("The character at index 2   is '" + anyString.charAt(2)   + "'");
console.log("The character at index 11 is '" + anyString.charAt(11) + "'");

// The character at index 0   is 'H'
// The character at index 1   is 'e'
// The character at index 2   is 'l'
// The character at index 11  is ''

String.prototype.concat()

描述 :
将原字符串与多个字符串拼接成新的字符串.
语法 :

str.concat(string[, string1, ..., stringN])

stringN : 要拼接的字符串.

1
2
3
4
let 你好世界 = 'Hello'.concat(' World');
console.log('你好世界 = ', 你好世界);

// 你好世界 =  Hello World

String.prototype.trim()

描述 :
将字符串的两端空白字符删除.
语法 :

str.trim()

1
2
3
4
5
6
let str_1_length = '       Hello World !    '.length;
let str_1 = '       Hello World !    '.trim();

console.log('str_1_length', str_1_length, 'str_1', str_1, str_1.length);

// str_1_length 24 str_1 Hello World ! 13

String.prototype.replace()

描述 :
在字符串中匹配并替换指定字符串.
语法 :

str.replace(regexp|string, newString|function)

regexp : 一个 RegExp 对象或者其字面量.
string : 待匹配的字符串, 仅仅是第一个匹配会被替换.
newString : 用于取代的字符串.
function : 每次匹配都要调用的函数.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
let str_1 = '521521521521'.replace('521', '我爱你');
let str_2 = '521521521521'.replace(/521/g, '我爱你');
let str_3 = '521521521521'.replace(/(521)/g, function(a, b, c, d){
  console.log('arguments', arguments);
  if (c === 0) return a;
  return '我爱你';
});

console.log('str_1', str_1);
console.log('str_2', str_2);
console.log('str_3', str_3);

// arguments { '0': '521', '1': '521', '2': 0, '3': '521521521521' }
// arguments { '0': '521', '1': '521', '2': 3, '3': '521521521521' }
// arguments { '0': '521', '1': '521', '2': 6, '3': '521521521521' }
// arguments { '0': '521', '1': '521', '2': 9, '3': '521521521521' }
// str_1 我爱你521521521
// str_2 我爱你我爱你我爱你我爱你
// str_3 521我爱你我爱你我爱你

String.prototype.split()

描述 :
在字符串中指定分隔符, 并在分隔符处分割字符串.
语法 :

str.split([separator[, limit]])

separator : 字符串或正则表达式. 若省略, 则返回的数组包含一个由整个字符串组成的元素.
limit : 限定返回的分割片段数量.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
let str_1 = 'Hello World'.split();
let str_2 = 'Hello World'.split('');
let str_3 = 'Hello World'.split(' ');
let str_4 = 'Hello World, Hello World, Hello World'.split(',', 2);
let str_5 = 'He5llo 2Worl1d'.split(/\d/);
let str_6 = 'He5llo 2Worl2d'.split(/(\d)/);


console.log('str_1',str_1);
console.log('str_2',str_2);
console.log('str_3',str_3);
console.log('str_4',str_4);
console.log('str_5',str_5);
console.log('str_5',str_6);

// str_1 [ 'Hello World' ]
// str_2 [ 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd' ]
// str_3 [ 'Hello', 'World' ]
// str_4 [ 'Hello World', ' Hello World' ]
// str_5 [ 'He', 'llo ', 'Worl', 'd' ]
// str_5 [ 'He', '5', 'llo ', '2', 'Worl', '2', 'd' ]

String.prototype.slice()

描述 :
提取字符串的一部分.
语法 :

str.slice(begin[, end])

begin(可选) : 起始索引, 默认值为0. 如果是负数, 则开始索引会被自动计算成为 str.length + start.
end : 终止索引, 默认值 str.length. 不包括end位置. 如果是负数时, 规则如上.

1
2
3
4
5
6
7
8
9
10
11
let str_1 = '0123456789'.slice();
let str_2 = '0123456789'.slice(-1);
let str_3 = '0123456789'.slice(1, -1);

console.log('str_1', str_1);
console.log('str_2', str_2);
console.log('str_3', str_3);

// str_1 0123456789
// str_2 9
// str_3 12345678

String.prototype.substring()

描述 :
提取字符串的一部分.
语法 :

str.substring(begin[, end])

begin : 起始索引.
end : 终止索引.

1
2
3
4
5
6
7
8
9
10
11
let str_1 = '0123456789'.substring();
let str_2 = '0123456789'.substring(0, 7);
let str_3 = '0123456789'.substring(7, 0);

console.log('str_1', str_1);
console.log('str_2', str_2);
console.log('str_3', str_3);

// str_1 0123456789
// str_2 0123456
// str_3 0123456

String.prototype.substr()

描述 :
提取字符串的一部分.
语法 :

str.substr(start[, length])

start(可选) : 起始索引, 默认值为0. 如果是负数, 则开始索引会被自动计算成为 str.length + start.
length : 提取的字符数.

1
2
3
4
5
6
7
8
9
10
11
let str_1 = '0123456789'.substr();
let str_2 = '0123456789'.substr(-3);
let str_3 = '0123456789'.substr(0, 6);

console.log('str_1', str_1);
console.log('str_2', str_2);
console.log('str_3', str_3);

// str_1 0123456789
// str_2 789
// str_3 012345

String.prototype.includes()

描述 :
判断字符串中是否有指定字符串. 依条件返回 true 或 false.
语法 :

str.includes(string[, position])

string : 需要查询的字符串.
position : 指定查询起始位置, 默认为 0.

1
2
3
4
5
6
7
let boolean_1 = 'Hello World'.includes('World');
let boolean_2 = 'Hello World'.includes('你好世界');
console.log('boolean_1 = ', boolean_1);
console.log('boolean_2 = ', boolean_2);

// boolean_1 =  true
// boolean_2 =  false

String.prototype.startsWith()

描述 :
判断字符串是否以指定字符串开头. 依条件返回 true 或 false.
语法 :

str.startsWith(string[, position])

string : 需要查询的字符串.
position : 指定字符串开头的位置, 默认值为 0.

1
2
3
4
5
6
7
8
9
10
11
let boolean_1 = '123456789'.startsWith(1);
let boolean_2 = '123456789'.startsWith(3, 4);
let boolean_3 = '123456789'.startsWith(7, 6);

console.log('boolean_1', boolean_1);
console.log('boolean_2', boolean_2);
console.log('boolean_3', boolean_3);

// boolean_1 true
// boolean_2 false
// boolean_3 true

String.prototype.endsWith()

描述 :
判断字符串是否以指定字符串结尾. 依条件返回 true 或 false.
语法 :

str.endsWith(string[, position])

string : 需要查询的字符串.
position : 指定字符串结尾的位置(字符串的长度), 默认值为 str.length.

1
2
3
4
5
6
7
8
9
10
11
let boolean_1 = '123456789'.endsWith(9);
let boolean_2 = '123456789'.endsWith(9, 8);
let boolean_3 = '123456789'.endsWith(7, 7);

console.log('boolean_1', boolean_1);
console.log('boolean_2', boolean_2);
console.log('boolean_3', boolean_3);

// boolean_1 true
// boolean_2 false
// boolean_3 true

String.prototype.indexOf()

描述 :
查询指定字符串在字符串中首次出现的索引位置. 若未查询到, 则返回 -1.
语法 :

str.indexOf(string[, position])

string : 需要查询的字符串.
position : 首次被找到的元素在数组中的索引位置, 默认值为 0.

1
2
3
4
5
6
7
8
9
10
11
let pos_1 = '0123456789'.indexOf(8);
let pos_2 = '0123456789'.indexOf(8, 9);
let pos_3 = '0123456789'.indexOf(8, 8);

console.log('pos_1', pos_1);
console.log('pos_2', pos_2);
console.log('pos_3', pos_3);

// pos_1 8
// pos_2 -1
// pos_3 8

String.prototype.lastIndexOf()

描述 :
从字符串的后面向前查找, 查询指定字符串在字符串中首次出现的索引位置. 若未查询到, 则返回 -1.
语法 :

str.lastIndexOf(string[, position])

string : 需要查询的字符串.
position : 逆向查找起始索引, 默认值 str.length - 1.

1
2
3
4
5
6
7
8
9
10
11
let pos_1 = '0123456789'.lastIndexOf(9);
let pos_2 = '0123456789'.lastIndexOf(9, 9);
let pos_3 = '0123456789'.lastIndexOf(9, 8);

console.log('pos_1', pos_1);
console.log('pos_2', pos_2);
console.log('pos_3', pos_3);

// pos_1 9
// pos_2 9
// pos_3 -1

String.prototype.match()

描述 :
字符串检索匹配正则表达式.
语法 :

str.match(regexp)

regexp : 正则表达式对象, 如果传入一个非正则表达式对象, 则会隐式地使用 new RegExp(obj) 将其转换为一个 RegExp. 如果你未提供任何参数, 直接使用 match(), 那么你会得到一个包含空字符串的 Array : [""].
返回值 : 如果字符串匹配到了表达式, 会返回一个数组, 数组的第一项是进行匹配完整的字符串, 之后的项是用圆括号捕获的结果. 如果没有匹配到, 返回null.

1
2
3
4
5
6
7
8
9
10
11
let pos_1 = '0123456789'.match(9);
let pos_2 = '0123456789'.match(/8\d+/);
let pos_3 = '0123456789'.match(/7\d{1}/);

console.log('pos_1', pos_1);
console.log('pos_2', pos_2);
console.log('pos_3', pos_3);

// pos_1 [ '9', index: 9, input: '0123456789' ]
// pos_2 [ '89', index: 8, input: '0123456789' ]
// pos_3 [ '78', index: 7, input: '0123456789' ]

描述 :
字符串检索匹配正则表达式.
语法 :

str.search(regexp)

regexp : 正则表达式对象, 如果传入一个非正则表达式对象, 则会隐式地使用 new RegExp(obj) 将其转换为一个 RegExp. 如果你未提供任何参数, 直接使用 match(), 那么你会得到一个包含空字符串的 Array : [""].
返回值 : 如果匹配成功, 则 search() 返回正则表达式在字符串中首次匹配项的索引. 否则, 返回 -1.

1
2
3
4
5
6
7
8
9
10
11
let pos_1 = '0123456789'.search(9);
let pos_2 = '0123456789'.search(/8\d+/);
let pos_3 = '0123456789'.search(/7\d{1}/);

console.log('pos_1', pos_1);
console.log('pos_2', pos_2);
console.log('pos_3', pos_3);

// pos_1 9
// pos_2 8
// pos_3 7

String.prototype.toLowerCase()

描述 :
将字符串转换成小写形式.
语法 :

str.toLowerCase()

1
2
3
4
5
let str_1 = 'Hello World !'.toLowerCase();

console.log('str_1', str_1);

// str_1 hello world !

String.prototype.toUpperCase()

描述 :
将字符串转换成大写形式.
语法 :

str.toUpperCase()

1
2
3
4
5
let str_1 = 'Hello World !'.toUpperCase();

console.log('str_1', str_1);

// str_1 HELLO WORLD !

String.prototype.toString()

描述 :
将指定对象转换成字符串形式.
语法 :

str.toString()

1
2
3
4
5
let str_1 = new String('Hello World !');

console.log('str_1', str_1, 'str_1.toString()', str_1.toString());

// str_1 [String: 'Hello World !'] str_1.toString() Hello World !(不同浏览器展现效果可能不同)

String.prototype.valueOf()

描述 :
返回一个String对象的原始值（primitive value）.
语法 :

str.valueOf()

1
2
3
4
5
6
let str = new String('Hello World!');
let str_1 = str.valueOf();

console.log('str_1', str_1);

// str_1 Hello World!

String.prototype[@@iterator]()

描述 :
返回一个String对象的原始值（primitive value）.
语法 :

str.valueOf()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
let str = 'Hello World!';
let str_1 = str[Symbol.iterator]();

console.log('str_1', str_1.next());

// str_1 { value: 'H', done: false }

for(let item of str) {
  console.log('item', item);
}
// item H
// item e
// item l
// item l
// item o
// item
// item W
// item o
// item r
// item l
// item d
// item !
------------- The End -------------
显示评论