常用
作用:找到有规则的文本
// 常用
. // 表示任意字符,不包括回车
\n // 回车
\d // 表示数字
\b // boundary 边界线,跟空格无关,而是词组的组成形式,英语是空格,中文是单字
{n} // n填数字,匹配前面的多个
\w // word,匹配字母数字或者下划线
\s // space 匹配空白符
+ // 前面的字符一个或多个
^ // 开头
$ // 结尾
$1 // 需要放在替换栏,表示匹配到的字符保存下来,$1,$2… 对应前边第n个（）包裹的东西
// 嵌套时从左到右看括号
? // 可有可无 -?\d+ 表示可有负号或者可以没有
[ab] // a或b
\t //水平制表符
\v //垂直制表符
\n //换行符
\r // 回车符
\0 // 空字符
\f // 换页符
\cX // 与X对应的控制字符(Ctrl+x)
修饰符
- g : global 全局搜索
- i : ignore case 忽略大小写
- m : multiple lines 多行搜索
默认下大小写敏感,且只匹配第一个匹配到的
元字符
* + ? ^ . | \ () {} []
范围类
表示一类,其中有一个即匹配,泛指某个特征的对象
[a-z] 表示所有小写字母
[a-zA-Z] 表示所有字母
[abc] 表示abc归为一类,有其中一个
^负向类,字符类取反
[^abc] 不包含a或b或c
预定义类
| 字符 | 等价类 | 含义 |
|---|---|---|
| . | [^\r\n] | 除了回车符和换行符之外的所有字符 |
| \d | [0-9] | 数字字符 |
| \s | [\t\n\xOB\f\r] | 空白符 space |
| \S | [^\t\n\xOB\f\r] | 非空白符 |
| \w | [a-zA-z_0-9] | 单词字符(字母\数字\下划线) |
| \W | [^a-zA-z_0-9] | 非单词字符 |
| \b | 单词边界 | |
| \B | 非单词边界 | |
| ^ | 以xxx开始 判断依据是前面是否为空白符 | |
| $ | 以xxx主动放弃 |
量词
| 字符 | 含义 |
|---|---|
| ? | 出现0次或1次(最多一次) |
| + | 出现1次或者多次(至少一次) |
| * | 出现0次或者多次(任意次) |
| {n} | 出现n次 |
| {n,m} | 出现n到m次 |
| {n,} | 至少出现n次 |
贪婪匹配&懒惰匹配模式
默认为贪婪模式,指有重复限定符时,匹配尽可能多的字符
限定符后使用?则使用懒惰匹配
懒惰匹配限定符
| 代码/语法 | 说明 |
|---|---|
| *? | 重复任意次，但尽可能少重复 |
| +? | 重复1次或更多次，但尽可能少重复 |
| ?? | 重复0次或1次，但尽可能少重复 |
| {n,m}? | 重复n到m次，但尽可能少重复 |
| {n,}? | 重复n次以上，但尽可能少重复 |
栗子
贪婪模式
'123456789'.replace(/\d{3,6}/,'x')
// 'xxxxxx789'
非贪婪模式下,会往最少的匹配
'123456789'.match(/\d{3,6}?/g)
// ['123','456','789']
捕获(分组)
// 自动命名分组
(abc){3} 使量词作用域分组
// 分组命名
(?<name>exp)
(?'name'exp) 命名为name的分组
// 不捕获(忽略分组)
(?:abc).(ok) // abc分组被忽略
// 反向引用
'2015-12-25'.replace(/(\d{4})-(\d{2})-(\d{2})/,'$2/$1/$3')
// 输出"12/25/2015"
// 引用命名
\k<name>
(?<abc>\d+)_\k<abc>\w+
// 可以在同一个正则里面用,在JavaScript RegExp对象方法.replace两个参数里也可以使用用于替换
零宽断言 (Lookahead and Lookbehind Zero-Length Assertions)
- 前瞻即匹配到规则,向前看(方向从文本末尾向开头称为前)检查是否符合断言
- 后顾/后瞻则相反
- 正向(正预测/正回顾)指条件语句匹配
- 负向相反
需注意JavaScript不支持后顾
| 名称 | 正则 | 含义 |
|---|---|---|
| 正预测先行断言(正向前瞻) | assert(?=exp) | assert后面必须匹配exp条件 |
| 负预测先行断言(负向前瞻) | assert(?!exp) | assert后面不能匹配exp条件 |
| 正回顾后发断言(正向后顾) | assert(?<=exp) | JavaScript不支持 |
| 负回顾后发断言(负向后顾) | assert(?<!exp) | JavaScript不支持 |
JavaScript中构建方式 RegExp 对象
字面量
/\b\w/g
// 斜杠之间为正则对象 斜杠右边为修饰符
构造函数
var reg = new RegExp('\\b\\w','g')
// 两个参数 第一参数注意转义
对象属性
ignoreCase：返回一个布尔值，表示是否设置了i修饰符，该属性只读。
global：返回一个布尔值，表示是否设置了g修饰符，该属性只读。
multiline：返回一个布尔值，表示是否设置了m修饰符，该属性只读。
lastIndex：返回下一次开始搜索的位置。该属性可读写，但是只在设置了g修饰符时有意义。
source：返回正则表达式的字符串形式（不包括反斜杠），该属性只读。
var reg = /abc/igm;
reg.gloabl // true 返回是否搜索全文
reg.ignoreCase // true 返回是否大小写忽略
reg.multiline // true 返回是否多行匹配
reg.lastIndex // 0 返回索引位置
reg.source // "abc" 返回正则表达式字符串形式
对象方法
RegExp.prototype.test()
返回一个布尔值,表示是否匹配
/apple/.test('牛顿吃苹果') // false
如果带g修饰符,则每一次test()都从上一次结束的位置开始向后匹配
var reg = /a/g
var string = "apple & apple"
reg.lastIndex // 0
reg.test(string) // true 匹配到第一个a
reg.lastIndex // 1 位置是第一个
reg.test(string) // true 匹配到第二个a
reg.lastIndex // 9 位置是第9个开始
reg.test(string) // false 匹配不到
reg.lastIndex // 0 匹配不到了
reg.test(string) // true 重新匹配到第一个
reg.lastIndex // 1 位置是第一个
RegExp.prototype.exec(str)
使用正则表达式模式对字符串进行搜索,并更新对象实例的属性,返回匹配结果。如果发现匹配，就返回一个数组，成员是每一个匹配成功的子字符串，否则返回null。
var s = 'cat'
var r1 = /a/
var r2 = /b/
r1.exec(s) // ["a"]
r2.exec(s) // null
如果正则表示式包含圆括号()（即含有“组匹配”），则返回的数组会包括多个成员。第一个成员是整个匹配成功的结果，后面的成员就是圆括号对应的匹配成功的组。也就是说，第二个成员对应第一个括号，第三个成员对应第二个括号，以此类推。整个数组的length属性等于组匹配的数量再加1。
var s = '_x_x';
var r = /_(x)/;
r.exec(s) // ["_x", "x"]
上面代码的exec()方法，返回一个数组。第一个成员是整个匹配的结果，第二个成员是圆括号匹配的结果,如果还有则继续匹配并返回到数组内
同时该数组还包含两个属性,需要注意这个与正则实例对象的属性不同
index 匹配成功的开始位置,从0开始计算
input 整个远字符串
var r = /a(p+)/
var arr = r.exec('_apple pine apple') // 是返回的数组才有属性
arr // ["app","pp"]
arr.index // 1 位置是第二个
arr.input // "_apple pine apple"
如果使用修饰符g,下一次搜索会从上次成功匹配结束的位置开始
var r = /a(p+)/g
var s = 'apple pine pine apple pine'
var a1 = r.exec(s)
a1 //["app","pp"]
a1.index // 0
r.lastIndex // 3
var a2 = r.exec(s)
a2 //["app","pp"]
a2.index // 16
r.lastIndex // 19
// 如果匹配不到了
var a3 = r.exec(s)
a3 // null
a3.index // TypeError: Cannot read property 'index' of null
r.lastIndex // 0
// 循环了
var a4 = r.exec(s)
a4 //["app","pp"]
a4.index // 0
r.lastIndex // 3
由于其存在循环的情况,我们利用返回的数组判断循环结束,一次循环完成所有匹配
var r = /a(b+)a/g;
var s = '_abbba_aba_';
while(true) {
var match = r.exec(s);
if (!match) break; //当数组结果不存在时就跳出循环
console.log(match[1]);
}
// bbb
// b
如果设置了lastIndex属性,就会从lastIndex位置开始匹配,需要g修饰符才生效
var r1 = /a(p+)/
r1.lastIndex = 5
var a1 = r1.exec('apple pine apple')
a1.index // 0
r1.lastIndex // 3
// 由于没有g 所以无效
var r2 = /a(p+)/g
r2.lastIndex = 5
var a2 = r2.exec('apple pine apple')
a2.index // 11
r2.lastIndex // 14
// 有g修饰符,所以生效
字符串对象方法 search() | match() | replace() | split()
search()
返回匹配结果的在字符串中的位置,g修饰符无效,因此lastIndex属性也无效
'apple pine apple'.search(/a(p+)/)
// 0
// 第一个位置,从0 开始数
'apple pine apple'.search(/bba/)
// -1
// 没匹配到
var r = /a(p+)/g;
r.lastIndex = 5; // 无效
'apple pine apple'.search(r) // 0
match()
返回匹配成功的的结果的数组,失败则返回null,g无效
var s = 'apple pine'
s.match(/a(p+)/) // ["app", "pp"]
s.match(/b(a+)/) // null
var r = /a(p+)/g
r.lastIndex = 5
s.match(r) // ["app", "pp"]
r.lastIndex // 0
// g修饰符无效
replace()
接受两个参数,第一个为搜索模式,第二个为替换内容,有g修饰符时替换所有字符
var s = 'apple'
s.replace(/p/,'b') // "abple"
s.replace(/p/g,'b') // "abble"
// 清除字符串两端空白符
var str = ' #id div.class ';
str.replace(/^\s+|\s+$/g, '')
// "#id div.class"
replace()方法的第二个参数可以使用美元符号$，用来指代所替换的内容
$& 指代匹配的子字符串。
$` 指代匹配结果前面的文本。
$' 指代匹配结果后面的文本。
$n 指代匹配成功的第n组内容，n是从1开始的自然数。
$$ 指代美元符号$。
'hello world'.replace(/(\w+)\s(\w+)/, '$2 $1')
// "world hello"
'abc'.replace('b', '[$`-$&-$\']')
// "a[a-b-c]c"
第二个参数还可以是函数,将匹配内容替换为函数返回值
该函数可接受多个参数,第一个为捕捉的内容match,第二个为第二个参数是捕捉到的组匹配（有多少个组匹配，就有多少个对应的参数）。此外，最后还可以添加两个参数，倒数第二个参数是捕捉到的内容在整个字符串中的位置（比如从第五个位置开始），最后一个参数是原字符串。
var prices = {
'pr_1': '$1.99',
'pr_2': '$9.99',
'pr_3': '$5.00'
};
var template = '/* ... */'; // 这里可以放网页模块字符串
template.replace(
/(<span id=")(.*?)(">)(<\/span>)/g,
function(match, $1, $2, $3, $4){
return $1 + $2 + $3 + prices[$2] + $4;
}
);
split()
字符串对象按正则规则分割,返回分割后组成的数组,接受两个参数,第一个为分割规则,第二个为最大成员数
// 非正则分隔
'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', '*' ]
参考:
http://javascript.ruanyifeng.com/stdlib/regexp.html
https://regexper.com/
http://www.regular-expressions.info/lookaround.html
