JavaScript String对象

491 2 年前
String对象是 JavaScript 原生提供的三个包装对象之一,用来生成字符串对象。允许操作和格式化文本字符串以及确定和定位字符串中的子字符串。

创建 String 对象

一、构造函数

let str = new String(s);
let str = String(s);

参数 s 是要存储在 String 对象中或转换成原始字符串的值。

String() 和运算符 new 一起作为构造函数使用时,它返回一个新创建的 String 对象,存放的是字符串 s 或 s 的字符串表示。

当不用 new 运算符调用 String() 时,它只把 s 转换成原始的字符串,并返回转换后的值。

二、字面量

var s1 = 'abc';

构造函数与字面量创建的String对象区别

var s1 = 'abc';
var s2 = new String('abc');

typeof s1 // "string"
typeof s2 // "object"

s2.valueOf() // "abc"

字符串对象是一个类数组对象

new String('abc')
// String {0: "a", 1: "b", 2: "c", length: 3}

(new String('abc'))[1] // "b"

String 对象的属性

属性 描述
constructor 指定用于创建对象的函数
length 返回 String 对象的长度
prototype 为对象的类返回原型的引用

String 对象的静态方法

函数 描述
String.fromCharCode 从若干 Unicode 字符值中返回一个字符串。
String.fromCodePoint 返回与 Unicode UTF-16 码位关联的字符串。
String.raw 返回模板字符串的原始字符串形式。

String.fromCharCode()

该方法的参数是一个或多个数值,代表 Unicode 码点,返回值是这些码点组成的字符串

该方法不支持 Unicode 码点大于0xFFFF的字符,即传入的参数不能大于0xFFFF(即十进制的 65535)

语法

String.fromCharCode([code1[, code2[, ...[, codeN]]]])

参数

  • code1, ..., codeN 可选。 要转换为字符串的一系列 Unicode 字符值。 如果不提供参数,则结果为空字符串。
String.fromCharCode(); // ""
String.fromCharCode(97); // "a"
String.fromCharCode(104, 101, 108, 108, 111);// "hello"

var test = String.fromCharCode(112, 108, 97, 105, 110);
console.log(test): //plain

码点大于0xFFFF的字符占用四个字节,而 JavaScript 默认支持两个字节的字符。这种情况下,必须把拆成两个字符表示

String.fromCodePoint()

返回与 Unicode UTF-16 码位关联的字符串。

语法

String.fromCodePoint(...codePoints);

参数

  • …codePoints:必需。指定一个或多个 UTF-16 码位值的 rest 参数。如果不是有效的 UTF-16 码位,此函数将引发 RangeError 异常。
var str1 = String.fromCodePoint(0x20BB7);
var str2 = String.fromCodePoint(98);
var str3 = String.fromCodePoint(97, 98, 99);

if(console && console.log) {
    console.log(str1);
    console.log(str2);
    console.log(str3);
}

// 𠮷
// b
// abc

String.raw()

返回模板字符串的原始字符串形式。函数旨在与模板字符串一起使用。原始字符串将包含存在于字符串中的任何转义字符和反斜杠

语法

String.raw`templateStr`;
String.raw(obj, ...substitutions);

参数

  • templateStr:必需。模板字符串。
  • obj:必需。一个使用对象文本表示法指定的格式正确的对象,例如 { raw: “value” }。
  • ...substitutions

可选。一个数组(rest 参数),包含一个或多个替换值。

function log(arg) {
    if(console && console.log) {
        console.log(arg);
    }
};

var name = "bob";

log(`hello \t${name}`);
log(String.raw`hello \t${name}`);
// The following usage for String.raw is supported but
// is not typical.
log(String.raw({ raw: 'fred'}, 'F', 'R', 'E'));

// Output:
// hello   bob
// hello \tbob
// fFrReEd 

String.raw`Hi\n${2+3}!`;
// 返回 "Hi\\n5!"

String.raw`Hi\u000A!`;
// 返回 "Hi\\u000A!"

String.raw()方法可以作为处理模板字符串的基本方法,它会将所有变量替换,而且对斜杠进行转义,方便下一步作为字符串来使用。

String.raww()方法也可以作为正常的函数使用。这时,它的第一个参数,应该是一个具有raw属性的对象,且raw属性的值应该是一个数组。

String.raw({ raw: 'test' }, 0, 1, 2);
// 't0e1s2t'

// 等同于
String.raw({ raw: ['t','e','s','t'] }, 0, 1, 2);

String 对象的实例方法。

方法 描述
charAt 方法 返回指定索引处的字符。
charCodeAt 方法 返回指定字符的 Unicode 编码。
codePointAt 方法 返回一个 Unicode UTF-16 字符的码位。
concat 方法(字符串) 返回由提供的两个字符串串联而成的字符串。
EndsWith 方法 返回一个布尔值,该值指示字符串或子字符串是否以传入字符串结尾。
includes 方法 返回一个布尔值,该值指示传入字符串是否包含在字符串对象中。
hasOwnProperty 方法 返回一个布尔值,该值指示某个对象是否具有指定名称的属性。
indexOf 方法(字符串) 返回字符串内第一次出现子字符串的字符位置。
isPrototypeOf 方法 返回一个布尔值,该值指示某个对象是否存在于另一个对象的原型链中。
lastIndexOf 方法(字符串) 返回字符串内子字符串的最后一个匹配项。
localeCompare 方法 返回一个值,该值指示两个字符串在当前区域设置中是否相等。
match 方法 通过使用提供的正则表达式对象来搜索字符串并以数组形式返回结果。
normalize 方法 返回指定字符串的 Unicode 范式。
propertyIsEnumerable 方法 返回一个布尔值,该值指示指定属性是否为对象的一部分且是否可枚举。
repeat 方法 返回一个新的字符串对象,它的值等于重复了指定次数的原始字符串。
replace 方法 使用正则表达式替换字符串中的文本并返回结果。
search 方法 返回正则表达式搜索中第一个子字符串匹配项的位置。
slice 方法(字符串) 返回字符串的片段。
split 方法 返回一个字符串拆分为若干子字符串时所产生的字符串数组。
StartsWith 方法 返回一个布尔值,该值指示字符串或子字符串是否以传入字符串开头。
substr 方法 返回一个从指定位置开始且具有指定长度的子字符串。
substring 方法 返回 String 对象中指定位置处的子字符串。
toLocaleLowerCase 方法 返回一个字符串,其中所有字母字符都转换为小写形式,并将考虑主机环境的当前区域设置。
toLocaleString 方法 返回使用当前区域设置转换为字符串的对象。
toLocaleUpperCase 方法 返回一个字符串,其中所有字母字符都转换为大写形式,并将考虑主机环境的当前区域设置。
toLowerCase 方法 返回一个字符串,其中所有字母字符都转换为小写形式。
toString 方法 返回字符串。
toUpperCase 方法 返回一个字符串,其中所有字母字符都转换为大写形式。
trim 方法 返回已移除前导空格、尾随空格和行终止符的字符串。
valueOf 方法 返回字符串。

charAt()

方法返回指定位置的字符,参数是从0开始编号的位置。如果index超出string,返回空字符

语法

string.charAt(index)

var s = new String('abc');
s.charAt(1) // "b"
s.charAt(s.length - 1) // "c"

这个方法完全可以用数组下标替代。

'abc'.charAt(1) // "b"
'abc'[1] // "b"

如果参数为负数,或大于等于字符串的长度,charAt返回空字符串。

'abc'.charAt(-1) // ""
'abc'.charAt(3) // ""

charCodeAt()

返回在指定的位置的字符的 Unicode 编码。如果index超出string,返回NaN

语法

string.charCodeAt(index)

'abc'.charCodeAt(1) // 98

如果没有任何参数,charCodeAt返回首字符的 Unicode 码点。

'abc'.charCodeAt() // 97

注意,charCodeAt方法返回的 Unicode 码点不会大于65536(0xFFFF),也就是说,只返回两个字节的字符的码点。如果遇到码点大于 65536 的字符(四个字节的字符),必需连续使用两次charCodeAt,不仅读入charCodeAt(i),还要读入charCodeAt(i+1),将两个值放在一起,才能得到准确的字符。

concat()

方法用于连接字符串,返回一个新字符串,不改变原字符串。如果参数不是字符串,concat方法会将其先转为字符串,然后再连接。

语法

string.concat(string1, string2, ..., stringX)

let s1 = 'abc';
let s2 = 'def';

let str = s1.concat(s2) // "abcdef"
s1 // "abc"

indexOf() lastIndexOf()

返回某个指定的字符串值在字符串中首次出现的位置。 如果没有找到匹配的字符串则返回 -1。 方法区分大小写。 搜索将从左向右执行。否则,此方法与 lastIndexOf 相同。

语法

strObj.indexOf(subString[, startIndex])

参数

  • subString 必选。要在字符串中搜索的子字符串

  • startIndex 可选。用于开始搜索 String 对象的索引。如果省略此参数,则搜索将从字符串的起始处开始。lastIndexOf的第二个参数表示从该位置起向前匹配

'hello world'.indexOf('o') // 4
'JavaScript'.indexOf('script') // -1
'hello world'.indexOf('o', 6) // 7
'hello world'.lastIndexOf('o') // 7
'hello world'.lastIndexOf('o', 6) // 4

match()

查找找到一个或多个与正则表达式匹配的子字符串。 match() 方法将检索字符串 String Object,以找到一个或多个与 regexp 匹配的文本。这个方法的行为在很大程度上有赖于 regexp 是否具有标志 g。如果 regexp 没有标志 g,那么 match() 方法就只能在 stringObject 中执行一次匹配。如果没有找到任何匹配的文本, match() 将返回 null。否则,它将返回一个数组,其中存放了与它找到的匹配文本有关的信息。

var str="The rain in SPAIN stays mainly in the plain"; 
var n=str.match(/ain/);//["ain", index: 5, input: "The rain in SPAIN stays mainly in the plain", groups: undefined]
var s=str.match(/ain/g);//["ain", "ain", "ain"]

'cat, bat, sat, fat'.match('at') // ["at"]
'cat, bat, sat, fat'.match('xt') // null

返回的数组还有index属性和input属性,分别表示匹配字符串开始的位置和原始字符串。

replace()

在字符串中查找匹配的子串, 并替换与正则表达式匹配的子串。 返回一个新的字符串,是用 replacement 替换了 regexp 的第一次匹配或所有匹配之后得到的 如果 regexp 具有全局标志 g,那么 replace() 方法将替换所有匹配的子串。否则,它只替换第一个匹配子串。 replacement 可以是字符串,也可以是函数。如果它是字符串,那么每个匹配都将由字符串替换。但是 replacement 中的 $ 字符具有特定的含义。如下表所示,它说明从模式匹配得到的字符串将用于替换。

语法

stringObj.replace(regexp/substr,replacement)

'aaa'.replace('a', 'b') // "baa"
字符 含义
$$ $
$& 指定 stringObj 中匹配整个模式的部分。
$` 指定 stringObj 中位于 $& 所描述的匹配项前面的部分
$' 指定 stringObj 中位于 $& 所描述的匹配项后面的部分。
$ n 第 n 个捕获到的子匹配,其中 n 为从 1 到 9 的十进制一位数。
$ nn 第 nn 个捕获到的子匹配,其中 nn 为从 01 到 99 的十进制二位数。
var s = "The quick brown fox jumped over the lazy dog.";
var re = /(\S+)(\s+)(\S+)/g;
// Exchange each pair of words.
var result = s.replace(re, "$3$2$1");
console.log(result);//quick The fox brown over jumps lazy the dog.

search()

查找正则表达式搜索中第一个子字符串匹配项。 如果没有找到任何匹配的子串,则返回 -1。 返回与指定查找的字符串或者正则表达式相匹配的 String 对象起始位置

语法

stringObj.search(rgExp)

'cat, bat, sat, fat'.search('at') // 1

var src = "is but a Dream within a dream";
var re = /dream/;
var pos = src.search(re);// 24 

re = /dream/i;
pos = src.search(re);// 9

slice()

方法用于从原字符串取出子字符串并返回,不改变原字符串。它的第一个参数是子字符串的开始位置,第二个参数是子字符串的结束位置(不含该位置)。

语法

stringObj.slice(start, [end])

参数

  • start:必需。指向 stringObj 指定部分的开头的索引。
  • end:可选。指向 stringObj 指定部分的结尾的索引。子字符串包括 end 所指示的字符(不包括该字符)前面的字符。如果没有指定该值,则子字符串将延续到 stringObj 的结尾。

如果 start 为负,则将其视为 length + start,此处 length 为字符串的长度。如果 end 为负,则会将其视为 length + end。如果省略 end,则将一直复制到 stringObj 的结尾。如果 end 出现在 start 之前,则不会将任何字符复制到新字符串中。

'JavaScript'.slice(0, 4) // "Java"
'JavaScript'.slice(4) // "Script"
'JavaScript'.slice(-6) // "Script"
'JavaScript'.slice(0, -6) // "Java"
'JavaScript'.slice(-2, -1) // "p"
'JavaScript'.slice(2, 1) // ""

split()

使用指定的分隔符将一个字符串拆分为多个子字符串,并将其以数组形式返回。

要查看英语原文,请勾选“英语”复选框。也可将鼠标指针移到文本上,在弹出窗口中显示英语原文。 翻译 英语 split 方法 (String) (JavaScript)

使用指定的分隔符将一个字符串拆分为多个子字符串,并将其以数组形式返回。

语法

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

参数

  • separator:可选。一个字符串或正则表达式对象,标识用于分隔字符串的一个或多个字符。如果忽略该参数,则将返回包含整个字符串的单元素数组。
  • limit:可选。一个用于限制数组中返回的元素数量的值。
'a|b|c'.split('|') // ["a", "b", "c"]
'a|b|c'.split('') // ["a", "|", "b", "|", "c"]
'a|b|c'.split() // ["a|b|c"]
'a||c'.split('|') // ['a', '', 'c']
'|b|c'.split('|') // ["", "b", "c"]
'a|b|'.split('|') // ["a", "b", ""]
'a|b|c'.split('|', 0) // []
'a|b|c'.split('|', 1) // ["a"]
'a|b|c'.split('|', 2) // ["a", "b"]
'a|b|c'.split('|', 3) // ["a", "b", "c"]
'a|b|c'.split('|', 4) // ["a", "b", "c"]

split()方法还可以使用正则表达式作为参数

substr()

从起始索引号提取字符串中指定数目的字符。方法的第一个参数是子字符串的开始位置(从0开始计算),第二个参数是子字符串的长度。

语法

stringvar.substr(start [, length ])

参数

  • start:必需。所需的子字符串的起始位置。字符串中第一个字符的索引为 0。负数,表示倒数计算的字符位置
  • length:可选。返回的子字符串中包含的字符数。

如果 length 为 0 或负数,则返回一个空字符串。如果没有指定该参数,则子字符串将延续到 stringvar 的结尾。

'JavaScript'.substr(4, 6) // "Script"
'JavaScript'.substr(4) // "Script"
'JavaScript'.substr(-6) // "Script"
'JavaScript'.substr(4, -1) // ""

substring()

用于从原字符串取出子字符串并返回,不改变原字符串,跟slice方法很相像。它的第一个参数表示子字符串的开始位置,第二个位置表示结束位置

语法

strVariable. substring(start [, end])
"String Literal".substring(start [, end])

参数

  • start:必需。从 0 开始的索引整数,指示子字符串的起始位置。
  • end:可选。从 0 开始的索引整数,指示子字符串的结束位置。子字符串包括 end 所指示的字符前面的字符(不包括end处字符)。如果省略 end,将返回从 start 一直到原字符串末尾的字符。

substring 方法使用 start 和 end 两者中的较小值作为子字符串的起始点。例如,strvar.substring(0, 3) 和 strvar.substring(3, 0) 将返回相同的子字符串。

如果 start 或 end 为 NaN 或负数,那么它将被替换为 0。

'JavaScript'.substring(0, 4) // "Java"
'JavaScript'.substring(4) // "Script"
'JavaScript'.substring(10, 4) // "Script"
// 等同于
'JavaScript'.substring(4, 10) // "Script"
'Javascript'.substring(-3) // "JavaScript"
'JavaScript'.substring(4, -3) // "Java"

toLowerCase()

返回一个新字符串,其中所有字母字符都转换为小写形式。

语法

strVariable.toLowerCase()

toUpperCase()

返回一个字符串,其中所有字母字符都转换为大写形式。

语法

strVariable.toLowerCase()

trim()

从字符串中移除前导空格、尾随空格和行终止符。 返回一个新字符串,不改变原字符串。 该方法去除的不仅是空格,还包括制表符(\t、\v)、换行符(\n)和回车符(\r)。

语法

stringObj.trim()

'  hello world  '.trim();  // "hello world"
'\r\nabc \t'.trim();  // 'abc'

valueOf()

返回某个字符串对象的原始值。 string.valueOf()

codePointAt()

返回指定位置的 Unicode utf-16 字符的码位

stringObj.codePointAt(pos);

此方法返回所有 UTF-16 字符的码位值,包括 astral 码位(具有四个以上的十六进制值的码位)。

如果 pos 小于零 (0) 或大于字符串大小,则返回值为undefined。

charCodeAt方法只能分别返回前两个字节和后两个字节的值 codePointAt方法,能够正确处理 4 个字节储存的字符,返回一个字符的码点

let s = '𠮷a';
s.codePointAt(0).toString(16) // "20bb7"
s.codePointAt(2).toString(16) // "61"

codePointAt方法的参数,仍然是不正确的。比如,上面代码中,字符a在字符串s的正确位置序号应该是 1,但是必须向codePointAt方法传入 2。解决这个问题的一个办法是使用for...of循环,解决这个问题的一个办法是使用for...of循环,因为它会正确识别 32 位的 UTF-16 字符。

let s = '𠮷a';
for (let ch of s) {
  console.log(ch.codePointAt(0).toString(16));
}
// 20bb7
// 61

at()

charAt方法期望返回的是用2个字节表示的字符,但汉字“𠮷”占用了4个字节,charAt(0)表示获取这4个字节中的前2个字节,很显然,这是无法正常显示的。有一个提案,提出字符串实例的at方法,可以识别 Unicode 编号大于0xFFFF的字符,返回正确的字符

'abc'.at(0) // "a"
'𠮷'.at(0) // "𠮷"

normalize()

ES6 提供字符串实例的normalize()方法,用来将字符的不同表示方法统一为同样的形式,这称为 Unicode 正规化

includes(), startsWith(), endsWith()

includes():返回布尔值,表示是否找到了参数字符串。 startsWith():返回布尔值,表示参数字符串是否在原字符串的头部。 endsWith():返回布尔值,表示参数字符串是否在原字符串的尾部。 这三个方法都支持第二个参数,表示开始搜索的位置。

let s = 'Hello world!';
s.startsWith('Hello') // true
s.endsWith('!') // true
s.includes('o') // true

let s = 'Hello world!';
s.startsWith('world', 6) // true
s.endsWith('Hello', 5) // true
s.includes('Hello', 6) // false

repeat()

返回一个新字符串,表示将原字符串重复n次。 参数如果是小数,会被取整,参数NaN等同于 0。 如果repeat的参数是负数或者Infinity,会报错。

'hello'.repeat(2) // "hellohello"
'x'.repeat(3) // "xxx"
'hello'.repeat(2) // "hellohello"
'na'.repeat(0) // ""

padStart(),padEnd()

字符串补全长度的功能。如果某个字符串不够指定长度,会在头部或尾部补全。padStart()用于头部补全,padEnd()用于尾部补全 一共接受两个参数,第一个参数用来指定字符串的最小长度,第二个参数是用来补全的字符串,省略第二个参数,默认使用空格补全长度

'x'.padStart(5, 'ab') // 'ababx'
'x'.padStart(4, 'ab') // 'abax'

'x'.padEnd(5, 'ab') // 'xabab'
'x'.padEnd(4, 'ab') // 'xaba'

'09-12'.padStart(10, 'YYYY-MM-DD') // "YYYY-09-12"

matchAll()

matchAll方法返回一个正则表达式在当前字符串的所有匹配

模板字符串

用反引号(`)标识,模板字符串中嵌入变量,需要将变量名写在${}之中,大括号内部可以放入任意的 JavaScript 表达式,可以进行运算,以及引用对象属性

let x = 1;
let y = 2;
`${x} + ${y} = ${x + y}`
// "1 + 2 = 3"
`${x} + ${y * 2} = ${x + y * 2}`
// "1 + 4 = 5"
let obj = {x: 1, y: 2};
`${obj.x + obj.y}`
// "3"
分类栏目
© 2018邮箱:11407215#qq.comGitHub沪ICP备12039518号-6