时间戳

首页 > 技术文章 > RegExp对象

RegExp对象

chris-jichen 2018-12-07 19:18 原文

原文地址：https://wangdoc.com/javascript/
RegExp对象提供正则表达式功能。

概述

新建正则表达式有两种方法，一种是使用字面量，以斜杠表示开始和结束。（推荐）

var regex = /xyz/;

另一种是使用RegExp构造函数。

var regex = new RegExp("xyz");

它们的区别在于，第一种方法在引擎编译代码时，就会新建正则表达式，第二种方法在运行时新建正则表达式，所以第一种方式效率较高。
RegExp构造函数还可以接受第二个参数，表示修饰符。

var regex = new RegExp("xyz", "i");
// 等价于
var regex = /xyz/i;

实例属性

正则对象的实例属性分为两类。
一类是修饰符相关，返回一个布尔值，表示对应的修饰符是否设置。

  • RegExp.prototype.ignoreCase：返回一个布尔值，表示是否设置了i修饰符。
  • RegExp.prototype.global：返回一个布尔值，表示是否设置了g修饰符。
  • RegExp.prototype.multiline：返回一个布尔值，表示是否设置了m修饰符。
    上面三个属性都是只读的。
    另一类是与修饰符无关的属性，主要是下面两个。
  • RegExp.prototype.lastIndex：返回一个整数，表示下一次开始搜索的位置。该属性可读写，但是只在进行连续搜索是有意义。
  • RegExp.prototype.source：返回正则表达式的字符串形式（不包括反斜杠），该属性只读。
var r = /abc/igm;
r.lastIndex; // 0
r.source; // abc

实例方法

RegExp.prototype.test()

正则实例对象的test方法返回一个布尔值，表示当前模式是否能匹配参数字符串。

/cat/.test("cats and dogs"); // true

如果正则表达式带有g修饰符，则每一次test方法都从上一次结束的位置开始向后匹配。

var r = /x/g;
var s = "_x_x";
r.lastIndex // 0
r.test(s) // true

r.lastIndex // 2
r.test(s) // true

r.lastIndex // 4
r.test(s) // false

注意，带有g的修饰符时，正则表达式内部会记住上一次的lastIndex属性，这时不应该更换要匹配的字符串，否则会有一些难以察觉的错误。

var r = /bb/g;
r.test("bb"); // true
r.test("-bb-"); // false

lastIndex属性只对同一个正则表达式有效，所以下面这样写是错误的。

var count = 0;
while (/a/g.test("babaa")) {
    count++;
}

上面代码会导致无限循环，因为while循环的每次匹配条件都是一个新的正则表达式，导致lastIndex属性总是等于0。
如果正则表达式是一个空字符串，则匹配所有字符串。

new RegExp("").test("abc"); // true

RegExp.prototype.exec()

正则实例对象的exec方法，用来返回匹配结果。如果发现匹配，就返回一个数组，成员是匹配成功的子字符串，否则返回null。

var s = "_x_x";
var r1 = /x/;
var r2 = /y/;

r1.exec(s); // ["x"]
r2.exec(s); // null

如果正则表达式包含圆括号（即含有组匹配），则返回的数组会包含多个成员。第一个成员是整个匹配成功的结果，后面的成员就是圆括号对应的匹配成功的组。也就是说，第二个成员对应第一个括号，第三个成员对应第二个括号，依此类推。

var s = "_x_x";
var r = /_(x)/;
r.exec(s) // ["_x", "x"]

上面返回的第一个成员是整个正则匹配的结果，第二个成员是圆括号内正则匹配的结果。
exec方法的返回数组还包含以下两个属性：

  • input：整个原字符串。
  • index：整个模式匹配成功的开始位置（从0开始计数）。
var r = /a(b+)a/;
var arr = r.exec("_abbba_aba_");

arr // ["abbba", "bbb"]

arr.index // 1
arr.input // "_abbba_aba_"

如果正则表达式加上g修饰符，则可以使用多次exec方法，下一次搜索的位置从上次匹配成功结束的位置开始。

var reg = /a/g;
var str = "abc_abc_abc";

var r1 = reg.exec(str);
r1 // ["a"]
r1.index // 0
reg.lastIndex // 1

var r2 = reg.exec(str);
r2 // ["a"]
r2.index // 0
reg.lastIndex // 4

字符串的实例方法

字符串的实例方法之中，有4种与正则表达式有关。

  • String.prototype.match()：返回一个数组，成员是所有匹配的字符串。
  • String.prototype.search()：按照给定的正则表达式进行搜索，返回一个整数，表示匹配开始的位置。
  • String.prototype.replace()：按照给定的正则表达式进行替换，返回替换后的字符串。
  • String.prototype.split()：按照给定规则进行字符串分割，返回一个数组，包含分割后的各个成员。

String.prototype.match()

字符串实例对象的match方法对字符串进行正则匹配，返回匹配结果。
在正则表达式没有g修饰符，该方法与正则对象的exec行为相同。
在正则表达式带有g修饰符，则该方法会一次性返回所有成功匹配的结果。

var s = "abba";
var r = /a/g;
s.match(r); ["a", "a"]
r.exec(s) // ["a"]

设置正则表达式的lastIndex属性，对match方法无效，匹配总是从字符串的第一个字符开始。

String.prototype.search()

字符串对象的search方法，返回第一个满足条件的匹配结果在整改字符串中的位置。如果没有匹配，则返回-1。

String.prototype.replace()

字符串对象的replace方法可以替换匹配的值。它接受两个参数，第一个是正则表达式，表示搜索模式，第二个是替换内容。如果正则表达式不加g修饰符，就替换第一个匹配成功的值，否则替换所有匹配成功的值。

"aaa".replace("a", "b"); // "baa"
"aaa".replace(/a/, "b"); // "baa"
"aaa".replace(/a/g, "b"); // "bbb"

replace方法的一个应用，就是消除字符串首尾两端的空格。

var str = "    #id div.class    ";
str.replace(/^\s+|\s+$/g, "")

replace方法的第二个参数可以使用美元符号$，用来指代所替换的内容。

  • $&：匹配的子字符串。
  • $`：匹配结果前面的文本
  • $'：匹配结果后面的文本。
  • $n：匹配成功的第n组内容，n是从1开始的自然数
  • $$：指代美元符号。
"hello world".replace(/(\w+)\s(\w+)/, "$2 $1"); "world hello"
"abc".replace("b", "[$`-$&-$\']"); // "a[a-b-c]c"

replace方法的第二个参数还可以是一个函数，将每一个匹配内容替换为函数返回值。

"3 and 5".replace(/[0-9]+/g, function(match) {
    return 2 * match;
});
// "6 and 10"
var a = "The quick brown fox jumped over the lazy dog.";
var pattern = /quick|brown|lazy/ig;
a.replace(pattern, function(match) {
    return match.toUpperCase();
});

作为replace方法第二个参数的替换函数，可以接受多个参数。其中，第一个参数是捕捉到的内容，第二个参数是捕捉到的组匹配（有多少个组匹配，就有多少个对应的参数）。此外，最后还可以添加两个参数，倒数第二个参数是捕捉到的内容在整个字符串的位置，最后一个参数是原字符串。

var prices = {
    "p1": "$1.99",
    "p2": "$9.99",
    "p3": "$5.00"
};

var template = '<span id="p1"></span>'
    + '<span id="p2"></span>'
    + '<span id="p3"></span>';

template.replace(/(<span id=")(.*?)(">)(<\/span>)/g, function(match. $1, $2, $3, $4) {
    return $1 + $2 + $3 + prices[$2] + $4;
});

String.prototype.split()

字符串对象的split方法按照正则规则分割字符串，返回一个由分割后的各个部分组成的数组。

str.split(separator, [limit])

该方法接受两个参数，第一个参数是正则表达式，表示分隔规则，第二个参数是返回数组的最大成员。

"a,   b,c,  d".split(","); // ["a", "   b", "c", "  d"]
// 正则分割，去除空格
"a,   b,c,  d".split(/, */); // ["a", "b", "c", "d"]
"a,   b,c,  d".split(/, */, 2); // ["a", "b"]

"aaa*a*".split(/a*/); // ["", "*", "*"]
"aaa**a*".split(/a*/); // ["", "*", "*", "*"] 第一个分隔符为aaa，第二个分隔符为0个a

如果正则表达式带有括号，则括号匹配的部分也会作为数组成员返回。

"aaa*a*".split(/(a*)/); ["", "aaa", "*", "a", "*"]

匹配规则

字面量字符和元字符

大部分字符串再正则表达式中，就是字面的含义，比如/a/匹配a。

点字符（.）

点字符（.）匹配除回车（\r）、换行（\n）、行分隔符（\u2028）和段分隔符（\u2029）以外的所有字符。注意，码点大于0xFFFF字符，点字符不能正确匹配。
比如c.t匹配cat、c2t但是不匹配coot。

位置字符串

位置字符用来提示字符所处的位置，主要有两个字符。

  • ^表示字符串的开始位置
  • $表示字符串的结束位置

选择符（|）

选择符（|）在正则表达式中表示或关系（OR），即cat|dog表示匹配cat或dog。

转义符

正则表达式中，需要反斜杠转义，一共有12个字符：^、.、[、$、(、)、|、*、+、?、{和\。如果使用RegExp方法生成正则对象，转义需要使用两个斜杠，因为字符串内部会先转义一次。

(new RegExp("1\\+1")).test("1+1"); // true

特殊字符

  • \cX表示Ctrl-[X]，其中的X是A-Z之中任一个英文字母，用来匹配控制字符。
  • [\b]匹配退格键（U+0008），不要与\b混淆。
  • \n匹配换行键。
  • \r匹配回车键。
  • \t匹配制表符。
  • \v匹配垂直制表符。
  • \f匹配换页符。
  • \0匹配null字符。
  • \xhh匹配一个以两位十六进制数（\x00-xFF）表示的字符。
  • \uhhhh匹配一个以四位十六进制数（\u0000-\uFFFF）表示的Unicode字符。

字符类

字符类表示有一系列字符可供选择，只要匹配其中一个就可以了。所有可供选择的字符都放在方括号内，比如[xyz]表示x、y、z之中任选一个匹配。

脱字符（^）

如果方括号内的第一个字符是^，则表示除了字符类之中的字符，其他的字符都可以匹配。比如[^xyz]除了x、y、z之外都可以匹配。
如果方括号内没有其他字符，即只有[^]，就表示匹配一切字符，其中包括换行符。相比之下，点号作为元字符（.）是不包括换行符的。

var s = "Please yes\nmake my day!"
s.match(/yes.*day/); // null
s.match(/yes[^]*day/); // ["yes\nmake my day"]

注意，脱字符只有在字符类的第一个位置（即[]内的第一个字符）才有特殊含义，否则就是字面含义。

连字符（-）

连字符（-）用来提供简写形式，表示字符的连续范围。比如，[abc]可以写成[a-c]，[1-31]不代表1到31，只代表1到3。
连字符还可以用来指定Unicode字符的范围，例如[\u0128-\uFFFF]。

预定义模式

预定义模式指的是某些常见模式的简写方式。

  • \d匹配0-9之间的任一数字，相当于[0-9]。
  • \D匹配所有0-9以外的字符，相当于[^0-9]。
  • \w匹配任意的字母、数字和下划线，相当于[A-Za-z0-9_]。
  • \W除所有字母、数字和下划线之外的字符，相当于[^A-Za-z0-9_]。
  • \s匹配空格（包括换行符、制表符、空格符等），相当于[ \t\r\n\v\f]。
  • \S匹配非空格的字符，相当于[^ \t\r\n\v\f]。
  • \b匹配词的边界。
  • \B匹配非词边界，即在词的内部。
/\bworld/.test("hello world") // true
/\bworld/.test(helloworld) // false

\b表示词的边界，所有world的词首必须独立（词尾是否独立未指定），才会匹配。

重复类

模式的精确匹配次数，使用大括号（{}）表示。{n}表示恰好重复n次，{n,}表示至少重复n次，{n,m}表示重复不少于n次，不多于m次。

量词符

量词符用来设定某个模式出现的次数。

  • ?问号表示某个模式出现0次或1次，等同于{0, 1}。
  • *星号表示某个模式出现0次或多次，等同于{0,}。
  • +加号表示某个模式出现1次或多次，等同于{1,}。

贪婪模式

三个量词符都是最大可能匹配，即匹配直到下一个字符不满足匹配规则为止。这种成为贪婪模式。如果想将贪婪模式改为非贪婪模式，可以在量词符后面加一个问号。

var s = "aaa";
s.match(/a+?/); // ["a"]

修饰符

g修饰符

见前文。

i修饰符

见前文。

m修饰符

m修饰符表示多行模式。会修改^和$的行为。不加m修饰符时，^和$匹配字符串的开始和结尾，加上m修饰符以后，^和$还会匹配行首和行尾，即^和$会识别换行符\n。

/world$/.test("hello world\n"); false
/world$/m.test("hello world\n"); true

组匹配

概述

正则表达式的括号表示分组匹配，括号中的模式可以用来匹配分组的内容。

var m = "abcabc".match(/(.)b(.)/);
m // ["abc", "a", "c"]

注意，使用组匹配时，不宜同时使用g修饰符，否则match方法不会捕获分组的内容。
正则表达式内部，还可以用\n引用括号匹配的内容，n从1开始的自然数，表示对应顺序的括号。

/(.)b(.)\1b\2/.test("abcabc") // true

上面的代码中，\1表示第一个括号匹配的内容（即a），\2表示第二个括号匹配的内容（即c）。
括号还可以嵌套。

/y((..)\2)\1/.test("yabababab") // true

上面代码中，\1指向外层括号，\2指向内层括号。

非捕获组

(?:x)成为非捕获组，表示不返回改组匹配的内容，即匹配的结果中不计入这个括号。

var m = "abc".match(/(?:.)b(.)/);
m // ["abc", "c"]

先行断言

x(?=y)称为先行断言，x只有在y前面才匹配，y不会被计入返回结果。比如，要匹配后面跟着百分号的数字，可以写成/\d+(?=%)/。

var m = "abc".match(/b(?=c)/);
m // ["b"]

上面代码中，使用了先行断言，b在c前面所以被匹配，但是括号对应的c不会被返回。

先行否定断言

x(?!y)称为先行否定断言，x只有不在y前面才匹配，y不被计入返回结果。

推荐阅读