new RegExp()

RegExp 构造函数创建了一个正则表达式对象，用于将文本与一个模式匹配。


语法

字面量,构造函数和工厂符号都是可以的： 

/pattern/flags
new RegExp(pattern [, flags])
RegExp(pattern [, flags])

参数

pattern
正则表达式的文本。
flags

如果指定，标志可以具有以下值的任意组合：

g
全局匹配;找到所有匹配，而不是在第一个匹配后停止
i
忽略大小写
m
多行;将开始和结束字符（^和$）视为在多行上工作（也就是，分别匹配每一行的开始和结束（由\n 或\r 分割），而不只是只匹配整个输入字符串的最开始和最末尾处。
u
Unicode;将模式视为Unicode序列点的序列
y
粘性匹配;仅匹配目标字符串中此正则表达式的lastIndex属性指示的索引(并且不尝试从任何后续的索引匹配)。
s
dotAll 模式，匹配任何字符（包括终止符'\n'）。

描述

有两种方法来创建一个RegExp对象：一是字面量、二是构造函数。要指示字符串，字面量的参数不使用引号，而构造函数的参数使用引号。因此，以下表达式创建相同的正则表达式： 

/ab+c/i;
new RegExp('ab+c', 'i');
new RegExp(/ab+c/, 'i');

当表达式被赋值时，字面量形式提供正则表达式的编译（compilation）状态，当正则表达式保持为常量时使用字面量。例如当你在循环中使用字面量构造一个正则表达式时，正则表达式不会在每一次迭代中都被重新编译（recompiled）。

而正则表达式对象的构造函数，如 new RegExp('ab+c') 提供了正则表达式运行时编译（runtime compilation）。如果你知道正则表达式模式将会改变，或者你事先不知道什么模式，而是从另一个来源获取，如用户输入，这些情况都可以使用构造函数。

从ECMAScript 6开始，当第一个参数为正则表达式而第二个标志参数存在时，new RegExp(/ab+c/,'i')不再抛出 TypeError （“当从其他正则表达式进行构造时不支持标志”）的异常，取而代之，将使用这些参数创建一个新的正则表达式。

当使用构造函数创造正则对象时，需要常规的字符转义规则（在前面加反斜杠\）。比如，以下是等价的： 

var re = new RegExp("\\w+");
var re = /\w+/;

正则表达式中特殊字符的含义

  • 字符类别（Character Classes）
  • 字符集合（Character Sets）
  • 边界（Boundaries）
  • 分组（grouping）与反向引用（back references）
  • 数量词（Quantifiers）
  • 断言（Assertions）
字符类别（Character Classes）
字符 含义
.

(点号，小数点)匹配任意单个字符，但是行结束符除外： \n \r \u2028 或 \u2029 。

在字符集中，点(.)失去其特殊含义，并匹配一个字面点(.)。

需要注意的是， m 多行（multiline）标志不会改变点号的表现。因此为了匹配多行中的字符集，可使用 [^] （当然你不是打算用在旧版本 IE 中），它将会匹配任意字符，包括换行符。

例如， /.y/ 匹配"yes make my day"中的"my"和"ay"，但是不匹配"yes"。

\d

匹配任意阿拉伯数字。等价于 [0-9] 。

例如， /\d/ 或 /[0-9]/ 匹配"B2 is the suite number."中的'2'。

\D

匹配任意一个不是阿拉伯数字的字符。等价于 [^0-9] 。

例如， /\D/ 或 /[^0-9]/ 匹配"B2 is the suite number."中的'B'。

\w

匹配任意来自基本拉丁字母表中的字母数字字符，还包括下划线。等价于 [A-Za-z0-9_] 。

例如， /\w/ 匹配"apple"中的'a'，"$5.28"中的'5'和"3D"中的'3'。

\W

匹配任意不是基本拉丁字母表中单词（字母数字下划线）字符的字符。等价于 [^A-Za-z0-9_] 。

例如， /\W/ 或 /[^A-Za-z0-9_]/ 匹配"50%"中的'%'。

\s

匹配一个空白符，包括空格、制表符、换页符、换行符和其他 Unicode 空格。

等价于 [\f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004 \u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f \u3000]。

例如 /\s\w*/ 匹配"foo bar"中的' bar'。

\S

匹配一个非空白符。等价于 [^\f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004 \u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000] 。

例如， /\S\w*/ 匹配"foo bar"中的'foo'。

\t 匹配一个水平制表符（tab）
\r 匹配一个回车符（carriage return）
\n 匹配一个换行符（linefeed）
\v 匹配一个垂直制表符（vertical tab）
\f 匹配一个换页符（form-feed）
[] 匹配一个退格符（backspace）（不要与 混淆）
\0 匹配一个 NUL 字符。不要在此后面跟小数点。
\c X

X 是 A - Z 的一个字母。匹配字符串中的一个控制字符。

例如， /\cM/ 匹配字符串中的 control-M。

\x hh 匹配编码为 hh （两个十六进制数字）的字符。
\u hhhh 匹配 Unicode 值为 hhhh （四个十六进制数字）的字符。
\

对于那些通常被认为字面意义的字符来说，表示下一个字符具有特殊用处，并且不会被按照字面意义解释。

例如 /b/ 匹配字符'b'。在 b 前面加上一个反斜杠，即使用 // ，则该字符变得特殊，以为这匹配一个单词边界。

或

对于那些通常特殊对待的字符，表示下一个字符不具有特殊用途，会被按照字面意义解释。

例如，*是一个特殊字符，表示匹配某个字符 0 或多次，如 /a*/ 意味着 0 或多个"a"。为了匹配字面意义上的 * ，在它前面加上一个反斜杠，例如， /a\*/ 匹配'a*'。

字符集合（Character Sets）
字符 含义
[xyz]

一个字符集合，也叫字符组。匹配集合中的任意一个字符。你可以使用连字符'-'指定一个范围。

例如，[abcd]等价于[a-d]，匹配"brisket"中的'b'和"chop"中的'c'。

[^xyz]

一个反义或补充字符集，也叫反义字符组。也就是说，它匹配任意不在括号内的字符。你也可以通过使用连字符'-'指定一个范围内的字符。

例如， [^abc] 等价于 [^a-c]。 第一个匹配的是"bacon"中的'o'和"chop"中的'h'。

边界（Boundaries）
字符 含义
^

匹配输入开始。如果多行（multiline）标志被设为 true，该字符也会匹配一个断行（line break）符后的开始处。

例如， /^A/ 不匹配"an A"中的"A"，但匹配"An A"中的"A"。

$

匹配输入结尾。如果多行（multiline）标志被设为 true，该字符也会匹配一个断行（line break）符的前的结尾处。

例如， /t$/ 不匹配"eater"中的"t"，但匹配"eat"中的"t"。

匹配一个零宽单词边界（zero-width word boundary），如一个字母与一个空格之间。（不要和 [] 混淆）

例如， /no/ 匹配"at noon"中的"no"， /ly/ 匹配"possibly yesterday."中的"ly"。

\B

匹配一个零宽非单词边界（zero-width non-word boundary），如两个字母之间或两个空格之间。

例如， /\Bon/ 匹配"at noon"中的"on"， /ye\B/ 匹配"possibly yesterday."中的"ye"。

分组（Grouping）与反向引用（back references）
字符 含义
( x )

匹配 x 并且捕获匹配项。这被称为捕获括号（capturing parentheses）。

例如， /(foo)/ 匹配且捕获"foo bar."中的"foo"。被匹配的子字符串可以在结果数组的元素 [1],...,[n] 中找到，或在被定义的 RegExp 对象的属性 $1,...,$9 中找到。

捕获组（Capturing groups）有性能惩罚。如果不需再次访问被匹配的子字符串，最好使用非捕获括号（non-capturing parentheses），见下面。

\ n

n 是一个正整数。一个反向引用（back reference），指向正则表达式中第 n 个括号（从左开始数）中匹配的子字符串。

例如， /apple(,)\sorange\1/ 匹配"apple, orange, cherry, peach."中的"apple,orange,"。一个更全面的例子在该表格下面。

(?: x ) 匹配 x 不会捕获匹配项。这被称为非捕获括号（non-capturing parentheses）。匹配项不能够从结果数组的元素 [1],...,[n] 或已被定义的 RegExp 对象的属性 $1,...,$9 再次访问到。
数量词（Quantifiers）
字符 含义
x *

匹配前面的模式 x 0 或多次。

例如， /bo*/ 匹配"A ghost booooed"中的"boooo"，"A bird warbled"中的"b"，但是不匹配"A goat grunted"。

x +

匹配前面的模式 x 1 或多次。等价于 {1,} 。

例如， /a+/ 匹配"candy"中的"a"，"caaaaaaandy"中所有的"a"。

x *?
x +?

像上面的* 和+ 一样匹配前面的模式 x ，然而匹配是最小可能匹配。

例如， /".*?"/ 匹配'"foo""bar"'中的'"foo"'，而* 后面没有? 时匹配'"foo""bar"'。

x ?

匹配前面的模式 x 0 或 1 次。

例如， /e?le?/ 匹配"angel"中的"el"，"angle"中的"le"。

如果在数量词 * 、 + 、 ? 或 {} ,任意一个后面紧跟该符号（?），会使数量词变为非贪婪（ non-greedy），即匹配次数最小化。反之，默认情况下，是贪婪的（greedy），即匹配次数最大化。

在使用于向前断言（lookahead assertions）时，见该表格中 (?=)、 (?!) 和 (?:) 的说明。

x | y

匹配 x 或 y

例如， /green|red/ 匹配"green apple"中的‘green'，"red apple."中的'red'。

x { n }

n 是一个正整数。前面的模式 x 连续出现 n 次时匹配。

例如， /a{2}/ 不匹配"candy,"中的"a"，但是匹配"caandy,"中的两个"a"，且匹配"caaandy."中的前两个"a"。

x { n ,}

n 是一个正整数。前面的模式 x 连续出现至少 n 次时匹配。

例如， /a{2,}/ 不匹配"candy"中的"a"，但是匹配"caandy"和"caaaaaaandy."中所有的"a"。

x { n , m }

n 和 m 为正整数。前面的模式 x 连续出现至少 n 次，至多 m 次时匹配。

例如， /a{1,3}/ 不匹配"cndy"，匹配"candy,"中的"a"，"caandy,"中的两个"a"，匹配"caaaaaaandy"中的前面三个"a"。注意，当匹配"caaaaaaandy"时，即使原始字符串拥有更多的"a"，匹配项也是"aaa"。

断言（Assertions），下面所有断言均只匹配 x ， y 不参与匹配
字符 含义
x (?= y )

仅匹配被y跟随的x。

举个例子， /Jack(?=Sprat)/ ，如果"Jack"后面跟着sprat，则匹配之。

/Jack(?=Sprat|Frost)/ ，如果"Jack"后面跟着"Sprat"或者"Frost"，则匹配之。但是，"Sprat"和"Frost"都不会在匹配结果中出现。

x (?! y )

仅匹配不被y跟随的x。

举个例子， /\d+(?!\.)/ 只会匹配不被点（.）跟随的数字。
/\d+(?!\.)/.exec('3.141') 匹配"141"，而不是"3.141"

(?<= y )x x 只有在 y 后面才匹配。
/(?<=\$)\d+/.exec('Benjamin Franklin is on the $100 bill')//["100"]
(?<! y )x x 只有不在 y 后面才匹配。
/(?<!\$)\d+/.exec('it’s is worth about €90')//["90"]
  1. ^ 等价于:

    [\t\n\v\f\r \u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000]

属性

RegExp.prototype
允许为所有正则对象添加属性。
RegExp.length
RegExp.length 值为 2。
Properties inherited from Function : arity , caller , constructor , length , name

方法

全局对象 RegExp 自身没有方法,不过它会继承一些方法通过原型链Methods inherited from Function : apply , call , toSource , toString

RegExp 实例

属性

查看已废弃的RegExp属性

注意， RegExp 对象的几个属性既有完整的长属性名，也有对应的类 Perl 的短属性名。两个属性都有着同样的值。JavaScript 的正则语法就是基于 Perl 的。

RegExp.prototype. constructor
创建该正则对象的构造函数。
RegExp.prototype.global
是否开启全局匹配，也就是匹配目标字符串中所有可能的匹配项，而不是只进行第一次匹配。
RegExp.prototype.ignoreCase
在匹配字符串时是否要忽略字符的大小写。
RegExp.prototype.lastIndex
下次匹配开始的字符串索引位置。
RegExp.prototype.multiline
是否开启多行模式匹配（影响^ 和$ 的行为）。
RegExp.prototype.source
正则对象的源模式文本。
RegExp.prototype.sticky
是否开启粘滞匹配。
Properties inherited from Object : __parent__ , __proto__

方法

查看已废弃的RegExp方法

RegExp.prototype.exec()
在目标字符串中执行一次正则匹配操作。
RegExp.prototype.test()
测试当前正则是否能匹配目标字符串。
RegExp.prototype.toSource()
返回一个字符串，其值为该正则对象的字面量形式。覆盖了 Object.prototype.toSource 方法.
RegExp.prototype.toString()
返回一个字符串，其值为该正则对象的字面量形式。覆盖了 Object.prototype.toString() 方法。
Methods inherited from Object : __defineGetter__ , __defineSetter__ , hasOwnProperty , isPrototypeOf , __lookupGetter__ , __lookupSetter__ , __noSuchMethod__ , propertyIsEnumerable , toLocaleString , unwatch , valueOf , watch

例子

例子：使用正则改变数据结构

下例使用 String ）去匹配姓名 first last 输出新的格式 last , first 。脚本中使用 $1 和 $2 指明括号里先前的匹配. 

var re = /(\w+)\s(\w+)/;
var str = "John Smith";
var newstr = str.replace(re, "$2, $1");
print(newstr);

显示"Smith, John".

例子：在多行中使用正则表达式 

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

例子:使用带有”sticky“标志的正则表达式

该例展示了，如何在正则表达式上使用 sticky 标志，用来匹配多行输入的单独行。 

var text = "First line\nsecond line";
var regex = /(\S+) line\n?/y;

var match = regex.exec(text);
print(match[1]);  // prints "First"
print(regex.lastIndex); // prints 11

var match2 = regex.exec(text);
print(match2[1]); // prints "Second"
print(regex.lastIndex); // prints "22"

var match3 = regex.exec(text);
print(match3 === null); // prints "true"

可以使用 try{…}catch{…} 来测试运行时（run-time）是否支持 sticky 标志。这种情况下，必须使用 eval(…) 表达式或 RegExp( regex-string , flags-string ) 语法（这是由于 / regex / flags 表示法将会在编译时刻被处理，因此在 catch 语句块处理异常前就会抛出一个异常。例如： 

var supports_sticky;
try { RegExp('','y'); supports_sticky = true; }
catch(e) { supports_sticky = false; }
alert(supports_sticky); // alerts "false" in Firefox 2, "true" in Firefox 3+

例子：使用正则表达式和 Unicode 字符

正如上面表格提到的， \w 或 \W 只会匹配基本的 ASCII 字符；如'a'到'z'、'A'到'Z'、 0 到 9 及'_'。为了匹配其他语言中的字符，如西里尔（Cyrillic）或希伯来语（Hebrew），要使用 \uhhhh ，"hhhh"表示以十六进制表示的字符的 Unicode 值。下例展示了怎样从一个单词中分离出 Unicode 字符。 

var text = "Образец text на русском языке";
var regex = /[\u0400-\u04FF]+/g;

var match = regex.exec(text);
print(match[1]);  // prints "Образец"
print(regex.lastIndex);  // prints "7"

var match2 = regex.exec(text);
print(match2[1]);  // prints "на" [did not print "text"]
print(regex.lastIndex);  // prints "15"

// and so on

这里有一个外部资源，用来获取 Unicode 中的不同区块范围：Regexp-unicode-block

例子：从 URL 中提取子域名 

var url = "http://xxx.domain.com";
print(/[^.]+/.exec(url)[0].substr(7)); // prints "xxx"

例子：dotAll flag使用 

/foo.bar/u.test('foo\nbar');
// → false

/foo.bar/su.test('foo\nbar');
// → true

上篇： RegExp

下篇： get RegExp[@@species]