本文属于 正则表达式系列文章之一,更多请前往 正则表达式系列
在快速入门
一文中,示例都是通过test()
方法演示,本文会继续介绍正则的其它用法(以JS
语言为例)
正则对象
生成正则对象
可选项标记
子表达式
正则的test
方法
正则的compile
方法
正则的exec
方法
字符串的正则应用
字符串的match
方法
字符串的replace
方法
字符串的search
方法
字符串的split
方法
有两种方法可以创建并得到一个正则表达式对象
字面量声明方式
var reg = /abc/g;
显式创建
var reg =new RegExp("abc", "g");
上文生成正则对象中最后有用到g
,其实这就是生成正则的可选项标记,可以组合使用,如下
g
全文匹配,即匹配一个成功后,如果没有结束,会继续匹配
i
忽略大小写匹配
m
多行匹配
可以通过如下示例进一步了解
/g
的用法
加上/g
后会全局搜索所有匹配结果
var str = 'abcabcabc';
// ['abc', index: 0, input: "abcabcabc"]
str.match(/abc/);
// ['abc', 'abc', 'abc']
str.match(/abc/g);
/i
的用法
加上/i
后大小写一视同仁,很多时候,如果不加/i
,很容易出现大小写不匹配的错误(比如去除字符串中script
标签时)
var str = 'Script';
// null
str.match(/script/);
// ["Script", index: 0, input: "Script"]
str.match(/script/i);
/m
的用法
多行匹配比较少用到,但在一些场景下不得不用,比如下例中,只有\m
多行匹配的情况下才能正常的将每一行的行尾(\n
形成不同的行)的数字替换成#
,否则默认会认为只有一行
var str = 'a1\nb1\nc1\nd1\ne1\nf1';
/**
* a1
* b1
* c1
* d1
* e1
* f#
*/
str.replace(/\d+$/g, '#')
/**
* a#
* b#
* c#
* d#
* e#
* f#
*/
str.replace(/\d+$/mg, '#')
正则表达式中,用圆括号包围的就是子表达式(子模式)
一般,在match
的非全局匹配中或exec
中,在匹配完整个正则表达表达式后,都会再次匹配子表达式
另外,在字符串的replace
与split
中,子表达式也会经常用到
var str = 'a1.b2.c3.d4';
// 第一个结果是 整个正则表达式的匹配,之后则分别是子表达式的匹配
/(\w)(\d)[.]/.exec(str); // ["a1.", "a", "1", index: 0, input: "a1.b2.c3.d4"]
pattern.test(str);
检索字符串中是否存在指定模式,匹配成功则返回true
,否则返回false
var str = 'abcdefg';
/^abc/.test(str); // true
/^abce/.test(str); // false
reg.compile(pattern);
编译正则表达式,编译之后正则的执行速度会提高
编译的时候也可以改变检索模式或者改变可选项标识
var str = 'abcdabcdabc';
var reg = /abc/;
reg.test(str); // true
reg.compile();
reg.test(str); // true,仅仅是被编译,没有被改变
reg.compile(/aB/);
reg.test(str); // false,匹配式改成了aB,因此不匹配
reg.compile(/aB/i);
reg.test(str); // true,改成了aB并且忽略大小的形式,因此匹配
pattern.exec(str);
在字符串中检索特定的模式,匹配成功则返回找到的值,否则返回null
有两种情况
第一种:非全局匹配
如果没有找到,则返回null
找到则返回一个数组,arr[0]
是匹配结果,余下元素是arr[0]中匹配圆括号中子表达式的结果,以及最后的index
和input
而且非全局模式中,不会保存index
,也就是说不管匹配多少次,结果都是一样的
var str = 'a1.b2.c3.d4';
var reg1 = /(\w)(\d)[.]/;
reg1.exec(str); // ["a1.", "a", "1", index: 0, input: "a1.b2.c3.d4"]
reg1.exec(str); // ["a1.", "a", "1", index: 0, input: "a1.b2.c3.d4"]
reg1.exec(str); // ["a1.", "a", "1", index: 0, input: "a1.b2.c3.d4"]
/abc/.exec(str); // null
第二种:g
全局匹配
正则的exec
全局匹配可以保存index
,并且下一次继续匹配时,将不会是重新从0
开始,而是从保存的index
开始
var str = 'a1.b2.c3.d4';
var reg2 = /(\w)(\d)[.]/g;
reg2.exec(str); // ["a1.", "a", "1", index: 0, input: "a1.b2.c3.d4"]
reg2.exec(str); // ["b2.", "b", "2", index: 3, input: "a1.b2.c3.d4"]
reg2.exec(str); // ["c3.", "c", "3", index: 6, input: "a1.b2.c3.d4"]
/abc/.exec(str); // null
上文中提到的都是正则对象上的方法,但实际上,JS
的String
对象也支持正则表达式
match
是字符串中最常用的方法
str.match(pattern);
如果pattern
中有g
,代表全局匹配,则返回的数组包含所有匹配结果
如果无g
,则返回的数组的第1
个元素(arr[0]
)是第一个匹配结果,余下元素是arr[0]
中匹配圆括号中子表达式的结果
var str = 'a.b2.c3.d445.e';
str.match(/\d[.]/); // ["2.", index: 3, input: "a.b2.c3.d445.e"]
// 非全局匹配下,并且有圆括号子表达式,先匹配整个正则表达式一次
// 然后在匹配结果中再匹配子表达式
str.match(/(\d)[.]/); // ["2.", "2", index: 3, input: "a.b2.c3.d445.e"]
// g 模式下是对整个正则表达式(包括圆括号子表达式)进行全局匹配
str.match(/(\d)[.]/g); // ["2.", "3.", "5."]
字符串中用来快速替换的方法,有多种用法
第一种情况
str.replace(str1, str2);
第一个参数是字符串,那么返回的结果只有str1
被替换成str2
了
var str = 'a.b2.c3.d4';
// 只会替换 . 一次
str.replace('.', '#'); // a#b2.c3.d445.e
第二种情况
str.replace(pattern, str2);
第一个参数是正则表达式,此时如果是g
全局匹配模式,会替换所有的匹配结果为str2
,否则只会替换一个匹配结果
var str = 'a.b2.c3.d4';
str.replace(/[.]/, '#'); // a#b2.c3.d445.e
str.replace(/[.]/g, '#'); // a#b2#c3#d445#e
另外此模式下,str2
还可以使用一些有特殊含义的特殊字符,例如
var str = 'a1.b2.c3.d4';
// $2和$1分别代表第2个,第1个子表达式
str.replace(/(\w)(\d)[.]*/g, '$2$1~'); // 1a~2b~3c~4d~
str2
中可用的特殊字符表
字符 | 替换 |
---|---|
$1,$2,…,$99 | 匹配第1~99个pattern中的圆括号子表达式的文本 |
$& | 匹配pattern的子串 |
$` | 匹配子串的左边文本 |
$’ | 匹配子串的右边文本 |
$$ | 美元符号 |
第三种情况
str.replace(pattern, func);
这种模式下,第二个参数为一个函数,func
将会在每一个匹配结果中调用,func
返回的字符串将作为替换文本,func
接收的参数,第一个是匹配pattern
的字符串,之后的参数(可能是多个)是匹配该pattern
中某个圆括号子表达式的字符串,在这之后的参数就是index
(匹配结果的位置),再之后就是完整的input
var str = a1.b2.c3.d4;
// 最终结果为: 1a~2b~3c~4d~
str.replace(/(\w)(\d)[.]*/g, function(word, child1, child2, index, input) {
console.log(word); // 依次打印的是a1. b2. c3. d4
console.log(child1); // 依次打印的是a b c d
console.log(child2); // 依次打印的是1 2 3 4
console.log(index); // 依次打印的是0 3 6 9
console.log(input); // 每次都是打印 a1.b2.c3.d4
return child2 + child1 + '~';
});
返回第1
个与patten匹配的字符串子串的起始位置,如果找不到,则返回-1
,不支持全局检索,也就是说,会省略g
var str = 'abcdefg1234567';
str.search(/efg/); // 4
str.search(/efg/g); // 4
str.search(/aabc/g); // -1
split
方法可以让一个字符串分割成数组,同样忽略g
str.split(pattern, limit); // pattern为字符串或正则
将str
拆分为子串组成的数组,子串中不包括pattern
(特例除外)。limit
是可选参数,指定返回的数组的最大长度
特例: 如果pattern
包含圆括号子表达式,则匹配这个圆括号子表达式的子串(不是匹配整个正则)会包含在返回数组中
var str = 'a1.b2.c3.d4';
str.split(/\d[.]/); // ["a", "b", "c", "d4"]
// 包含了圆括号的子串,返回数组中出现了匹配圆括号的子串
str.split(/(\d)[.]/); // ["a", "1", "b", "2", "c", "3", "d4"]
var str2 = '.b2.c3.';
// 3.后面没有字符了,但是由于它符合匹配,所以后续结果中会多一个""
str2.split(/\d[.]/); // [".b", "c", ""]
// 同上,只不过圆括号中的内容也在返回结果中
str.split(/(\d)[.]/); // [".b", "2", "c", "3", ""]