正则表达式
正则表达式(Regular Expression)，使用单个字符串来描述、匹配一系列匹配某个法规则的字符串。简单来说就是按照某种规则去匹配符合条件的字符串。
javascript 通过内置函数对象 RegExp 支持正则表达式，有两种方法实例化 RegExp 对象：
- 字面量
- 构造函数
//字面量方式
var reg = /\bis\b/;
'He is a boy. This is a dog. Where is she?'.replace(reg,'IS');
//He IS a boy. This is a dog. Where is she?
var reg = /\bis\b/g;
'He is a boy. This is a dog. Where is she?'.replace(reg,'IS');
//He IS a boy. This IS a dog. Where IS she?
//构造函数
var reg = new RegExp('\\bis\\b');
'He is a boy. This is a dog. Where is she?'.replace(reg,'IS');
//He IS a boy. This is a dog. Where is she?
var reg = new RegExp('\\bis\\b','g');
'He is a boy. This is a dog. Where is she?'.replace(reg,'IS');
//He IS a boy. This IS a dog. Where IS she?
修饰符
- g:global全文搜索，不添加，搜索到第一个匹配停止
- i:ignore case 忽略大小写，默认大小写敏感
- m multiple lines 多行搜索
'He is a boy. Is she?'.replace(/\bis\b/g,'0');
//He 0 a boy. Is she?
'He is a boy. Is she?'.replace(/\bis\b/gi,'0');
//He 0 a boy. 0 she?
元字符
正则表达式由两种基本字符类型组成：
- 原义文本字符
- 元字符：在正则表达式中含有特殊含义的非字母字符
| 字符 | 含义 |
|---|---|
| \t | 水平制表符 |
| \v | 垂直制表符 |
| \n | 换行符 |
| \r | 回车符 |
| \0 | 空字符 |
| \f | 换页符 |
| \cX | 与X对应的控制字符（ctrl + x） |
字符类
- 一般情况下正则表达式一个字符对应字符串一个字符
- 表达式
ab\t的含义是
ab\t
- 可以使用元字符
[]来构建一个简单的类（指符合某些特性的对象，一个泛指，而不是特指某个字符） - 表达式
[abc]把字符a或b或c归为一类，表达式可以匹配这类的字符
[abc]
'a1b2c3d4'.replace(/[abc]/g,'x');//x1x2x3d4
字符类取反
- 使用元字符
^创建反向类/负向类（即不属于某类的内容） - 表达式
[^abc]表示不是字符a或b或c的内容
[^abc]
'a1b2c3d4'.replace(/[^abc]/g,'x');//axbxcxxx
范围类
- 使用
[a-z]来连接两个字符表示从a 到z的任意字符（这是个闭区间，即包含a和z本身）
[a-z]
'a1b2c3d4z9'.replace(/[a-z]/g,'Q')//Q1Q2Q3Q4Q9
'a1b2c3d4z9KJFD'.replace(/[a-zA-Z]/g,'Q')//Q1Q2Q3Q4Q9QQQQ
'2016-09-21'.replace(/[0-9]/g,'A');//AAAA-AA-AA
'2016-09-21'.replace(/[0-9-]/g,'A');//AAAAAAAAAA
预定义类
| 字符 | 等价类 | 含义 |
|---|---|---|
| . | [^\r\n] | 除了回车符和换行符之外的所有字符 |
| \d | [0-9] | 数字字符 |
| \D | [^0-9] | 非数字字符 |
| \s | [\t\n\x0B\f\r] | 空白字符 |
| \S | [^\t\n\x0B\f\r] | 非空白字符 |
| \w | [a-zA-Z_0-9] | 单词字符（字母、数字、下划线） |
| \W | [^a-zA-Z_0-9] | 非单词字符 |
//匹配一个ab + 数字 + 任意字符 的字符串
ab[0-9][^\r\n] == ab\d.
边界
| 字符 | 含义 |
|---|---|
| ^ | 以xxx开始 |
| $ | 以xxx结束 |
| \b | 单词边界 |
| \B | 非单词边界 |
'This is a boy'.replace(/is/g,"0")；//Th0 0 a boy
'This is a boy'.replace(/\bis\b/g,"0")；//This 0 a boy
'This is a boy'.replace(/\Bis\b/g,"0")；//Th0 is a boy
'@123@abc@'.replace(/@./g,"Q");//Q23Qbc@
'@123@abc@'.replace(/^@./g,"Q");//Q23@abc@
'@123@abc@'.replace(/.@/g,"Q");//Q12QabQ
'@123@abc@'.replace(/.@$/g,"Q");//@123@abQ
var mulSrt = "@123
@456
@789
";
mulSrt.replace(/^@\d/g,"X");
/*x23
@456
@789*/
mulSrt.replace(/^@\d/gm,"X");
/*X23
X56
X89*/
量词
| 字符 | 含义 |
|---|---|
| ? | 出现零次或一次（最多出现一次） |
| + | 出现一次或多次（最少出现一次） |
| * | 出现零次或多次（任意次） |
| {n} | 出现n次 |
| {n,m} | 出现n到m次 |
| {n,} | 至少出现n次 |
\d{20}\w\d?\w+\d*\d{3}\w{3,5}\d{3,}
\d{20}\w\d?\w+\d*\d{3}\w{3,5}\d{3,}
贪婪模式
一般情况下，正则表达式在匹配过程中会尽可能多的匹配
"12345678".replace(/\d{3,6}/g,"X");//X78
非贪婪模式
让正则表达式尽可能少的匹配，就是说一旦成功匹配不再继续尝试。在量词后加上+即可
"123456789".match(/\d{3,5}?/g,"X");//["123", "456", "789"]
"12345678".replace(/\d{3,6}?/g,"X");//XX78
分组
使用()可以达到分组的功能，使量词作用于分组
(Byron){3}:
(Byron){3}
Byron{3}:
Byron{3}
"a1b2c3d4".replace(/[a-z]\d{3}/g,"x");//a1b2c3d4
"a1b2c3d4".replace(/([a-z]\d){3}/g,"x");//xd4
或
使用|可以达到或的效果
'ByronCasper'.replace(/Byron|Casper/g,"x")//xx
'ByronsperByrCasper'.replace(/Byr(on)|(Ca)sper/g,"x")//xsperByrx
反向引用
'2016-11-23'.replace(/(\d{4})-(\d{2})-(\d{2})/g,'$2/$3/$1');//11/23/2016
忽略分组
不希望捕获分组，只需要在分组内加上?:就可以
(?:Byron).(ok):
(?:Byron).(ok)
前瞻
正则表达式从文本头部向尾部开始解析，文本尾部方向，称为“前”。前瞻就是正则表达式匹配到规则的时候，向前检查是否符合断言，后顾/后瞻方向相反。
- javascript 不支持后顾
- 符合和不符合特定断言称为肯定/正向匹配和否定/负向匹配
| 名称 | 正则 | 含义 |
|---|---|---|
| 正向前瞻 | exp(?=assert) | |
| 负向前瞻 | exp(!=assert) | |
| 正向后顾 | exp(?<=assert) | js不支持 |
| 正向后顾 | exp(?<!assert) | js不支持 |
'a2*34vv'.replace(/\w(?=\d)/g,'x');//x2*x4vv
对象属性
- global：是否全文搜索，默认false
- ignore case:是否大小写敏感，默认false
- multiline :多行搜索,默认false
- lastIndex:当前表达式匹配内容的最后一个字符的下一个位置
- source:正则表达式的文本字符串
var reg1 = /\w/;
var reg2 = /\w/gim;
console.log(reg1.global);//false
console.log(reg1.ignoreCase);//false
console.log(reg1.multiline);//false
console.log(reg1.source);//\w
console.log(reg2.global);//true
console.log(reg2.ignoreCase);//true
console.log(reg2.multiline);//true
console.log(reg2.source);//\w
//以上属性为只读状态
test 和 exec方法
RegExp.prototype.test(str)
用于测试字符串参数中是否存在匹配正则表达式模式的字符串，存在返回true，反之，返回false
var reg1 = /\w/;
var reg2 = /\w/g;
reg1.test('a');//true
reg1.test('$');//false
reg2.test('ab');//true,重复执行多遍时，结果可能为false
while(reg2.test('ab')){
console.log(reg2.lastIndex);
//1
//2
}
RegExp.prototype.exec(str)
使用正则表达式模式对字符串执行搜索，并将更新全局RegExp对象的属性以反映匹配结果。如果没有匹配文本则返回null,否则返回一个结果数组：
- index:声明匹配文本的第一个字符的位置
- input：存放被检索的字符串string
非全局调用
- 调用非全局的RegExp对象的exec()时，返回数组
- 第一个元素：与正则表达式匹配的文本
- 第二元素：与RegExpObject的第一个子表达式相匹配的文本（如果有的话）
- 第三元素：与RegExpObject的第二个子表达式相匹配的文本（如果有的话），以此类推
var reg3 = /\d(\w)\d/;
var reg4 = /\d(\w)\d/g;
var ts = '
$1az2bb3cy4dd5ee';
var ret = reg3.exec(ts);
console.log(reg3.lastIndex + "\t" + ret.index + "\t" +ret.toString());
//0 1 1az2,a,z
console.log(reg3.lastIndex + "\t" + ret.index + "\t" +ret.toString());
//0 1 1az2,a,z(非全局搜索，lastIndex 不生效)
while(ret = reg4.exec(ts)){
console.log(reg4.lastIndex + "\t" + ret.index + "\t" +ret.toString());
// 5 1 1az2,a,z
//11 7 3cy4,c,y
}
字符串对象方法
String.prototype.search(reg)
用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串，返回第一个匹配结果index,查不到返回-1。不执行全局匹配，总是从字符串的开始进行检索。
'a1b2c3d41'.search('1');//1
'a1b2c3d41'.search('10');//-1
'a1b2c3d41'.search(/1/);//1
'a1b2c3d41'.search(/1/g);//1
String.prototype.match(reg)
将检索字符串，找到一个或多个与regexp匹配的文本，regexp有无g标志，对结果有影响。
非全局调用
没有标志g，match()只能在字符串中执行一次匹配，如果没有找到匹配文本返回null,否则将返回数组，其中存放与它找到的匹配文本有关的信息：
- 第一元素：匹配文本，而其余的元素存放的是与正则表达式的子表达式匹配的文本
- index:声明匹配文本的起始字符在字符串的位置
- input：对stringObject的引用
var reg3 = /\d(\w)\d/;
var reg4 = /\d(\w)\d/g;
var ts = '$1a2b3c4d5e';
var ret = ts.match(reg3);
console.log(ret);//['1a2',a]
console.log(ret.index + '\t' + reg3.lastIndex);//1 0
ret = ts.match(reg4);
console.log(ret);//['1a2','3c4']
console.log(ret.index + '\t' + reg4.lastIndex);//undefined 0
全局调用
有g标志的match()方法将执行全局检索，找到字符串中所有匹配子字符串，没有找到返回null,找到则返回数组。数组中存放所有匹配的子字符串，没有index和input属性。
String.prototype.split(reg)
'a1b2c3d4'.split(/\d/g);//[a,b,c,d]
String.prototype.replace()
- String.prototype.replace(str,replaceStr)
- String.prototype.replace(reg,replaceStr)
- String.prototype.replace(reg,function)
function会在每次匹配的时候调用，有四个参数：
- 匹配字符串
- 正则表达式分组内容，没有分组则没有改参数
- 匹配项在字符串中的index
- 原字符串
'a1b2c3d4e5'.replace(/\d/g,function(match,index,origin){
console.log(index);
return parseInt(match) + 1;
})
'a1b2c3d4e5'.replace(/(\d)(\w)(\d)/g,function(match,group1,group2,group3,index,origin){
console.log(match);
return group1 + group2;
})
网友评论