RegExp对象
Regular Experssion
运用单个字符串来形貌、婚配一系列相符某个句法划定规矩的字符串
测试网站:https://regexper.com
建立体式格局
- 字面量
var reg = /\bis\b/g
"he is a boy".replace(reg,'IS')
//"he IS a boy"
- 组织函数
var reg = new RegExp('\\bis\\b','g');
"he is a boy".replace(reg,'IS')
//"he IS a boy"
元字符
正则表达式由两种基础字符范例构成:
- 原义文本字符
元字符
- 元字符是在正则表达式中有特别寄义的非字母字符
-
*
+
?
$
^
.
|
\
()
{}
[]
字符类
平常情况下正则表达式一个字符对应字符串一个字符
表达式ab\t
的寄义是
我们也能够运用元字符
[]
来构建一个简朴的类
所谓类是指相符某些特性的对象,一个泛指,而不是特指某个字符
表达式[abc]
把字符a
或b
或c
归为一类,表达式能够婚配这类的字符,
'a1b2c3d3'.replace(/[abc]/g,'X')
"X1X2X3d3"
字符串取反
- 运用元字符
^
建立反向类/负向类 - 反向类的意义是不属于某类的内容
- 表达式
[^abc]
示意不是字符a或b或c
的内容
局限类
- 正则表达式还供应了局限类
- 能够用
[a-z]
来衔接两个字符示意从a到z的恣意字符
- 这是个闭区间,也就是包括a和z自身
'a1b2c3d4x5z6'.replace(/[a-z]/g,'X')
//"X1X2X3X4X5X6"
在
[]
构成的类内部是能够连写的
[a-zA-Z]
'a1b2c3d4x5z6DSFDAFDAFD'.replace(/[a-zA-Z]/g,'X')
//"X1X2X3X4X5X6DSFDAFDAFD"
这类情况下怎样婚配到’-‘?只需要在背面补上一个’-‘就好了
'a1b2-c-3d4x5z6DS-F-DAFDAFD'.replace(/[a-zA-Z-]/g,'X')
//"X1X2XXX3X4X5X6XXXXXXXXXXXX"
JS预定义类及边境
预定类:
"This is a boy".replace(/\Bis\b/,'0')
//"Th0 is a boy"
几个常常使用的边境婚配字符:
示例一:
"This is a boy".replace(/is/g,'0')
//"Th0 0 a boy"
只想替代第一个’is
"This is a boy".replace(/\Bis\b/,'0')
//"Th0 is a boy"
只想替代第二个
"This is a boy".replace(/\bis\b/g,'0')
//"This 0 a boy"
示例二:
"@123@345@".replace(/@./g,'Q')
//"Q23Q45@"
只想替代第一个
"@123@345@".replace(/^@./g,'Q')
//"Q23@345@"
只替代末了一个
"@123@345@".replace(/.@$/g,'Q')
//"@123@34Q"
var mulstr = "@123
@456
@678";
mulStr.replace(/^@\d/gm,'x')
// X123
X456
X678
量词
我们愿望婚配一个一连涌现20次数字的字符串:
明显不能用这中体式格局:\d\d\d\d\d\d\d\d\d\d\d\d\d\d\d\d\d\d\d\d\d
?
+
*
JS正则贪欲形式与非贪欲形式
贪欲形式
正则表达式在婚配的时刻会尽量多的婚配,直到婚配失利
"12345678".replace(/\d{3,6}/g,'X')
//"X78"
//123456 -> X
非贪欲形式
- 让正则表达式尽量少的婚配,也就是说一旦胜利婚配不再继承尝试就黑白贪欲形式
- 做法很简朴,在量词背面加上
?
即可
"12345678".replace(/\d{3,6}?/g,'X')
//"XX78"
//123,456 -> X,X
分组
()
婚配字符串
Byron
一连涌现三次的场景,能够会用Byron{3}
并不能到达我们期待的结果,只会处置惩罚紧挨着的,
用()
能够到达分组的功用,使量词作用域分组:
'a1b2c3d4'.replace(/[a-z]\d{3}/g,'X')
//"a1b2c3d4"
'a1b2c3d4'.replace(/([a-z]\d){3}/g,'X')
//"Xd4"
或
运用|
到达结果
Byron|Casper
'ByronCasper'.replace(/Byron|Casper/g,'X')
// "XX"
'ByronsperByrCasper'.replace(/Byr(on|Ca)sper/g,'X')
//"XX"
反向援用
2015-12-25 --> 12/25/2015
'2015-12-25'.replace(/(\d{4})-(\d{2})-(\d{2})/g,'$2/$3/$1')
//"12/25/2015"
疏忽分组
不愿望捕捉某些分组,只需要在分组内加上?:
就能够
(?:Byron).(ok)
不让捕捉分组
前瞻
- 正则表达式从文本头部向尾部最先剖析,文本尾部方向
-
前瞻
就是在正则表达式婚配到划定规矩的时刻,向前搜检是不是相符断言,后顾/后瞻方向相反 - javascript不支持后顾
- 相符和不相符特定断言称为一定/正向婚配和否认/负向婚配
前瞻
'a2*3'.replace(/\w(?=\d)/g,'X')
//"X2*3"
JS对象属性
对象属性
-
g
:global
全文搜刮,不增加,搜刮到第一个婚配住手 -
i
:ignore case
疏忽大小写,默许大小写敏感 -
m
:multiple lines
多行搜刮 -
lastIndex
:是当前表达式婚配内容的末了一个字符的下一个位置 -
source
:正则表达式的文本内容框
var reg1 = /\w/
var reg2 = /\w/gim
reg1.ignoreCase
//false
reg1.multiline
//false
reg1.global
//false
reg2.ignoreCase
//true
reg2.multiline
//true
reg2.global
//true
test和exec要领
test
RegExp.prototype.test(str)
- 用于测试字符串参数中是不是存在婚配正则表达式形式的字符串
- 假如存在则返回
true
,不存在则返回false
var reg1 = /\w/
var reg2 = /\w/g
while(reg2.test('ab')){
console.log(reg2.lastIndex)
}
//1
//2
exec
RegExp.prototype.exec(str)
- 运用正则表达式形式对字符串实行搜刮,并将更新全局
RegExp
对象的属性以反应婚配结果 假如没有婚配的文本则返回null,不然返回一个结果数组
-
index
声明婚配文本的第一个字符的位置 -
input
寄存被检索的字符串string
-
非全局挪用
- 挪用非全局的
RegExp
对象的exec()
时,返回数组 - 第一个元素是与正则表达式相婚配的文本
- 第二个元素是与
RegExpObject
的第一个子表达式相婚配的文本(假如有的话) - 第三个元素是与
RegExp
对象的第二个子表达式相婚配的文本(假如有的话),以此类推
var reg3 = /\d(\w)(\w)\d/
var reg4 = /\d(\w)(\w)\d/g
var ts = '1az2bb3cy4dd5cc'
var ret = reg3.exec(ts)
console.log(reg3.lastIndex+'\t'+ret.index+'\t'+ret.toString())
//"0 0 1az2,a,z"
//非全局lastIndex不见效,reg3.lastIndex并未见效
console.log(reg3.lastIndex+'\t'+ret.index+'\t'+ret.toString())
//"0 0 1az2,a,z"
while(ret = reg4.exec(ts)){
console.log(reg4.lastIndex+'\t'+ret.index+'\t'+ret.toString())
}
//"4 0 1az2,a,z"
//"10 6 3cy4,c,y"
字符串对象要领
String.prototype.search(reg)
-
search()
要领用于检索字符串中指定的子字符串,或检索与正则表达式相婚配的子字符串 - 要领返回第一个婚配结果
index
,查找不到返回-1 -
search()
要领不实行全局婚配,它将疏忽标志g
,而且老是从字符串的最先举行检索
'dafd1afd'.search(/1/g)
//4
//输入数字也能婚配到,尝试往正则表达式转
String.prototype.match(reg)
-
match()
要领将检索字符串,以找到一个或多个与regexp
婚配的文本 -
regexp
是不是具有标志g
对结果影响很大
非全局挪用
- 假如没有
regexp
没有标志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)
console.log(ret.index+'\t'+reg3.lastIndex)
//["1a2", "a", index: 1, input: "$1a2b3c4d5e", groups: undefined]
// 1 0
全局挪用
假如
regexp
具有标志g
则match()
要领将实行全局检索,找到字符串中的一切婚配字符串- 没有找到任何婚配的字符串,则返回
null
- 假如找到了一个或多个婚配字符串,则返回一个数组
- 没有找到任何婚配的字符串,则返回
- 数组元素中寄存的是字符串中一切的婚配子串,而且也没有
index
属性或input
属性
var reg3 = /\d(\w)\d/
var reg4 = /\d(\w)\d/g
var ts = '$1a2b3c4d5e'
var ret = ts.match(reg4)
console.log(ret)
console.log(ret.index+'\t'+reg4.lastIndex)
//["1a2", "3c4"]
//undefined 0
String.prototype.split(reg)
- 我们常常运用
split
要领将字符串支解为字符数组
'a,b,c,d'.split(',') //["a","b","c","d"]
- 在一些庞杂的支解情况下我们能够运用正则表达式处理
'a1b2c3d'.split(/\d/);
//["a", "b", "c", "d"]
'a1.b|2c3d'.split(/\.|\|/);
//["a1", "b", "2c3d"]
String.prototype.replace()
String.prototype.replace(str,replaceStr)
'a1b1c1'.replace('1',2)
//"a2b1c1"
String.prototype.replace(reg,replaceStr)
'a1b1c1'.replace(/1/,2)
//"a2b1c1"
String.prototype.replace(reg,function)
function
会在每次婚配替代的时刻挪用,有四个参数
- 1、婚配字符串
- 2、正则表达式分组内容,没有分组则没有该参数
- 3、婚配项在字符串中的
index
- 4、原字符串
'a1b2c3d4' => 'a2b3c4d5'
'a1b2c3d4e5'.replace(/\d/g,function(match,index,origin){
console.log(index)
return parseInt(match) + 1
})
// 1
//3
//5
//7
//9
//"a2b3c4d5e6"
'a1b2c3d4e5'.replace(/(\d)(\w)(\d)/g,function(match,group1,group2,group3,index,origin){
console.log(index)
return parseInt(group1)+parseInt(group3)
})
// 1
//5
//"a3c7e5"