javascript中正好则表明式的底子语法

前方的言语

  正则表明式在众人的回想中或者是同一积不可以知道的字符,但虽然是这个号却实现了字符串的高速操作。平日的情事是,问题我并无复杂,但没正则表明式就变成了老大题材。javascript中之正则表明式作为至极重大之学问,本文将介绍正则表达式的功底语法

 

定义

  正则表达式(Regular
Expression)是相同门户简单语言的语法规范,是强、便捷、高效的文本处理工具,它利用在有的方吃,对字符串中之信息实现查找、替换和领取操作

  javascript中的正则表明式用RegExp对象表示,有半点栽写法:一栽是许面量写法;另一样种植是构造函数写法

Perl写法

  正则表达式字面量写法,又于Perl写法,因为javascript的正则表达式特性借鉴自Perl

  正则表明式字面量定义为涵盖在一如既往针对性斜杠(/)之间的字符,并且可设置3单标志

var expression = /pattern/flags;

  正则表明式的至极情势襄助下列3独标志:

  g:表示全局(global)情势,即模式将被拔取被所有字符串,而不要在发现第一个门当户对配项时这停下

  i:表示未区分轻重缓急写(case-insensitive)形式,即当确定匹配项时忽略形式以及字符串的轻重写

  m:表示多履行(multiline)模式,即以到一行文本末尾时还会面持续寻找下一行中是不是留存与格局匹配的起

//匹配字符串所有'at'的实例
var p = /at/g;
//test()方法返回一个布尔值表示是否可以找到匹配项
console.log(p.test('ata'));//true
console.log(p.test('aba'));//false

RegExp构造函数

  和经常的搁对象同,RegExp正则表达式对象啊支撑new
RegExp()构造函数的款型

  RegExp构造函数接收两单参数:要配合的字符串情势(pattern)和可选的标志字符串(flags),标志字符串和字面量的老六个标志含义相同:’g’、’i’、’m’

  RegExp构造函数的少数独参数仍旧字符串。且下字面量情势定义之任何表达式都只是使用构造函数

//匹配字符串所有'at'的实例
var p1 = /at/g;
//同上
var p2 = new RegExp('at','g');

  [注意]ES3规范规定,一个正则表明式直接量会于实践及她时时易为一个RegExp对象,同一段代码所表示正则表明式直接量的历次运算都归跟一个靶。ES5正规则举办了反而的确定,同一段代码所表示的正则表明式直接量的历次运算都回去新目的。IE6-8直接是听从ECMAScript5标准之不二法门贯彻之,所以并从未兼容性问题

 

特点

  javascript中的正则表明式最要命之特性是无协理空白,必须写在一行中

//匹配ab
console.log(/ab/.test('ab')); //true
console.log(/ ab/.test('ab')); //false
console.log(/a b/.test('ab')); //false
console.log(/ab /.test('ab')); //false

 

元字符

  大部分字符在正则表明式中,就是字面的义,比如/a/匹配a,/b/匹配b

/dog/.test("old dog") // true

  但还有部分字符,它们除了字面意思外,还享有特殊之意思,这一个字符就是第一字符

  于javascript中,共有14单元字符(meta-character)

() [] {} \ ^ $ | ? * + . 

元字符         名称              匹配对象
.             点号               单个任意字符(除回车\r、换行\n、行分隔符\u2028和段分隔符\u2029外)
[]            字符组             列出的单个任意字符
[^]           排除型字符组        未列出的单个任意字符
?             问号               匹配0次或1次
*             星号               匹配0交或多次
+             加号               匹配1次或多次
{min,max}     区间量词            匹配至少min次,最多max次
^             脱字符             行的起始位置
$             美元符             行的结束位置
|             竖线               分隔两边的任意一个表达式
()            括号               限制多选结构的范围,标注量词作用的元素,为反向引用捕获文本
\1,\2...      反向引用            匹配之前的第一、第二...组括号内的表达式匹配的文本

 

转义字符

  转义字符(escape)表示也反斜线(\)+字符的款式,共有以下3种植状态

  【1】因为元字符有特殊的意义,所以不可以直接匹配。假诺假若配合它们自身,则要在其前加上反斜杠(\)

console.log(/1+1/.test('1+1')); //false
console.log(/1\+1/.test('1+1')); //true

console.log(/\*/.test('*')); //true
console.log(/*/.test('*')); //报错

  但其实,并非14只元字符都需要转义,右方括号]和左边花括号}不需要转义

console.log(/]/.test(']')); //true
console.log(/\]/.test(']')); //true

console.log(/\}/.test('}')); //true
console.log(/}/.test('}')); //true

  【2】’\’加非元字符,表示有免克打印的特殊字符

\0        NUL字符\u0000
[\b]      匹配退格符\u0008,不要与\b混淆
\t        制表符\u0009
\n        换行符\u000A
\v        垂直制表符\u000B
\f        换页符\u000C
\r        回车符\u000D
\xnn      由十六进制数nn指定的拉丁字符
\uxxxx    由十六进制数xxxx指定的Unicode字符(\u4e00-\u9fa5代表中文)  
\cX       控制字符^X,表示ctrl-[X],其中的X是A-Z之中任一个英文字母,用来匹配控制字符

  【3】’\’加任意其他字符,默认情状就算是匹配此字符,也就是说,反斜线(\)被忽略了

console.log(/\x/.test('x')); //true
console.log(/\y/.test('y')); //true
console.log(/\z/.test('z')); //true

更转义

  由于RegExp构造函数的参数是字符串,所以某些意况下,需要针对字符举办再转义

  字符\于正则表明式字符串中平日给转义为\\

var p1 = /\.at/;
//等价于
var p2 = new RegExp('\\.at');

var p1 = /name\/age/;
//等价于
var p2 = new RegExp('name\\/age');

var p1 = /\w\\hello\\123/;
//等价于
var p2 = new RegExp('\\w\\\\hello\\\\123');

 

字符组

  字符组(Character
Class),有的编译成字符类或字符集。简单而言,就是指用方括号表示的平组字符,它十分若干字符之一

//匹配0-9这10个数字之一
var p = /[0123456789]/;
p.test('1');//true
p.test('a');//false

  [注意]字符组中之字符排列顺序并无影响字符组的职能,出现又字符也非相会潜移默化

/[0123456789]/
//等价于
/[9876543210]/
//等价于
/[1234567890123456789]/

范围

  正则表明式通过并字符(-)提供了限表示法,可以简化字符组

/[0123456789]/
//等价于
/[0-9]/

/[abcdefghijklmnopqrstuvwxyz]/
//等价于
/[a-z]/

  连字符(-)表示的限制是遵照ASCII编码的码值来规定的,码值小之于后面,码值大之于晚

图片 1

  所以[0-9]凡是官方的,而[9-0]会报错

//匹配0-9这10个数字之一
var p1 = /[0-9]/;
p1.test('1');//true
var p2 = /[9-0]/;//报错
p2.test('1');

  以字符组中得又并列多独’-‘范围

/[0-9a-zA-Z]/;//匹配数字、大写字母和小写字母
/[0-9a-fA-F]/;//匹配数字,大、小写形式的a-f,用来验证十六进制字符

console.log(/[0-9a-fA-F]/.test('d'));//true
console.log(/[0-9a-fA-F]/.test('x'));//false

  唯有当字符组内部,连字符’-‘才是处女字符,表示一个克,否则她就只可以配合普通的连字符号

  [注意]假设并字符出现在字符组的最先或最终,它意味着的也罢是不以为奇的连字符号,而未是一个限

//匹配中划线
console.log(/-/.test('-'));//true
console.log(/[-]/.test('-'));//true

//匹配0-9的数字或中划线
console.log(/[0-9]/.test('-'));//false
console.log(/[0-9-]/.test('-'));//true
console.log(/[0-9\-]/.test('-'));//true
console.log(/[-0-9]/.test('-'));//true
console.log(/[\-0-9]/.test('-'));//true

排除

  字符组的另一个色是排除型字符组,在左手括号后紧跟一个脱字符’^’表示,表示于如今地方匹配一个不曾排有底字符 

  所以[^0-9]代表0-9之外的字符

//匹配第一个是数字字符,第二个不是数字字符的字符串
console.log(/[0-9][^0-9]/.test('1e'));//true
console.log(/[0-9][^0-9]/.test('q2'));//false

  [注意]于字符组内部,脱字符’^’表示免除,而在字符组外部,脱字符’^’表示一个行锚点

  ^符号是头字符,在字符组中设^符号不沿在左手括号就可象征该自身含义,不转义也足以

//匹配abc和^符号
console.log(/[a-c^]/.test('^'));//true
console.log(/[a-c\^]/.test('^'));//true
console.log(/[\^a-c]/.test('^'));//true

  以字符组中,唯有^、-、[、]当时4只字符或为作为元字符,其他暴发元字符效能的字符都不过象征其本人

console.log(/[[1]]/.test('['));//false
console.log(/[[1]]/.test(']'));//false
console.log(/[\1]/.test('\\'));//false
console.log(/[^^]/.test('^'));//false
console.log(/[1-2]/.test('-'));//false

console.log(/[\[1\]]/.test('['));//true
console.log(/[\[1\]]/.test(']'));//true
console.log(/[\\]/.test('\\'));//true
console.log(/[^]/.test('^'));//true
console.log(/[1-2\-]/.test('-'));//true

console.log(/[(1)]/.test('('));//true
console.log(/[(1)]/.test(')'));//true
console.log(/[{1}]/.test('{'));//true
console.log(/[{1}]/.test('}'));//true
console.log(/[1$]/.test('$'));//true
console.log(/[1|2]/.test('|'));//true
console.log(/[1?]/.test('?'));//true
console.log(/[1*]/.test('*'));//true
console.log(/[1+]/.test('+'));//true
console.log(/[1.]/.test('.'));//true

简记

  用[0-9]、[a-z]相当于字符组,可以死方便地表示数字字符和小写字母字符。对于当下仿佛时由此字符组,正则表达式提供了又简单的记法,这就是是字符组简记(shorthands)

  常见的字符组简记有\d、\w、\s。其中d表示(digit)数字,w表示(word)单词,s表示(space)空白

  正则表明式也供了对诺排除型字符组的简记法:\D、\W、\S。字母完全相同,只是改变吗好写,这个简记法匹配的字符上

\d     数字,等同于[0-9]
\D     非数字,等同于[^0-9]
\s     空白字符,等同于[\f\n\r\t\u000B\u0020\u00A0\u2028\u2029]
\S     非空白字符,等同于[^\f\n\r\t\u000B\u0020\u00A0\u2028\u2029]
\w     字母、数字、下划线,等同于[0-9A-Za-z_](汉字不属于\w)
\W     非字母、数字、下划线,等同于[^0-9A-Za-z_]

  [注意]\w不仅包括字母、数字,还包下划线。在进展数字证实时,只同意输入字母和数字时,不得以接纳\w,而应当下[0-9a-zA-Z]

轻易字符

  人们一般认为点号可以象征擅自字符,其实并无是

  .点号代表除回车(\r)、换行(\n)
、行分隔符(\u2028)和段分隔符(\u2029)以外的任意字符

  妥善的应用上属性,可以得到有精粹纷呈的效率。比如,[\s\S]、[\w\W]、[\d\D]都足以代表任意字符

//匹配任意字符
console.log(/./.test('\r'));//false
console.log(/[\s\S]/.test('\r'));//true

 

量词

  按照字符组的牵线,可以据此字符组[0-9]或\d来匹配单个数字字符,倘若因而正则表达式表示又复杂的字符串,则非顶有利

//表示邮政编码6位数字
/[0-9][0-9][0-9][0-9][0-9][0-9]/;
//等价于
/\d\d\d\d\d\d/;

  正则表明式提供了量词,用来设定有形式起的次数

{n}       匹配n次
{n,m}     匹配至少n次,最多m次
{n,}      匹配至少n次
?         相当于{0,1}
*         相当于{0,}
+         相当于{1,}

//表示邮政编码6位数字
/\d{6}/;

  美利坚合众国斯洛伐克语与英国阿拉伯语来把词的写法不一致,假诺traveler和traveller,favor和favour,color和colour

//同时匹配美国英语和英国英语单词
/travell?er/;
/favou?r/;
/colou?r/;

  协商名有http和https三种

/https?/;

  量词广泛应用于解析HTML代码。HTML是一模一样栽标签语言,它包含各种各种的签,比如<head>、<img>、<table>。它们都是自<先导,到>停止,而标签名的长不同

console.log(/<[^<>]+>/.test('<head>'));//true
console.log(/<[^<>]+>/.test('<img>'));//true
console.log(/<[^<>]+>/.test('<>'));//false

  HTML标签不能啊空标签,而引号字符串的蝇头个引号之间可以啊0单字符

console.log(/'[^']*'/.test("''"));//true
console.log(/'[^']*'/.test("'abc'"));//true

贪得无厌格局

  默认情状下,量词都是贪心情势(greedy
quantifier),即匹配到下一个字符不知足匹配规则停止

//exec()方法以数组的形式返回匹配结果
/a+/.exec('aaa'); // ['aaa']

好逸恶劳情势

  懒惰形式(lazy
quantifier)和贪婪形式相呼应,在量词后加问号’?’表示,表示尽可能少的配合,一旦条件满意就再也未为生匹配

{n}?       匹配n次
{n,m}?     匹配至少n次,最多m次
{n,}?      匹配至少n次
??         相当于{0,1}
*?         相当于{0,}
+?         相当于{1,}

/a+?/.exec('aaa'); // ['a']

  匹配<script></script>之间的代码看上去挺轻

/<script>[\s\S]*<\/script>/

//["<script>alert("1");</script>"]
/<script>[\s\S]*<\/script>/.exec('<script>alert("1");</script>'); 

  但假如反复面世script标签,就会生问题

//["<script>alert("1");</script><br><script>alert("2");</script>"]
/<script>[\s\S]*<\/script>/.exec('<script>alert("1");</script><br><script>alert("2");</script>');     

  它把无用的<br>标签也配合出来了,此时即需用懒惰情势

//["<script>alert("1");</script>"]
/<script>[\s\S]*?<\/script>/.exec('<script>alert("1");</script><br><script>alert("2");</script>');     

  在javascript中,/*
*/是注释的一样种格局,在文档中或出现频,这时便必须动懒惰形式

/\/\*[\s\S]*?\*\//

//["/*abc*/"]
/\/\*[\s\S]*?\*\//.exec('/*abc*/<br>/*123*/');

 

括号

  括号发出点儿单职能,分别是分组和援。具体而言,用于限定量词或拔取项之企图范围,也可以用来捕获文本并开展引用或反向引用

分组

  量词控制前元素的面世次数,而此因素或是一个字符,也恐怕是一个字符组,也不过一个表达式

  假如拿一个表明式用括号包围起来,这些因素就是括号里的表明式,被称为子说明式

  倘使期待字符串’ab’重复出现2次,应该写吧(ab){2},而如写为ab{2},则{2}只限定b

console.log(/(ab){2}/.test('abab'));//true
console.log(/(ab){2}/.test('abb'));//false
console.log(/ab{2}/.test('abab'));//false
console.log(/ab{2}/.test('abb'));//true

  身份证尺寸有15各和18各二种,借使单纯十分长度,可能会师怀想当地刻画成\d{15,18},实际上就是一无是处的,因为它们包括15、16、17、18眼看四种植长度。因而,正确的写法应该是\d{15}(\d{3})?

  email地址以@分隔成稀截,此前的有些是用户称,之后的有是主机名

  用户称允许出现数字、字母和下划线,长度一般在1-64独字符中,则正则只是代表也/\w{1,64}/

  主机名一般表现吗a.b.···.c,其中c为主域名,其他也级反复不必然的子域名,则正则只是代表为/([-a-zA-z0-9]{1,63}\.)+[-a-zA-Z0-9]{1,63}/

  所以email地址之正则表明式如下:

    var p =/\w{1,64}@([-a-zA-z0-9]{1,63}\.)+[-a-zA-Z0-9]{1,63}/;
    console.log(p.test('q@qq.com'));//true
    console.log(p.test('q@qq'));//false
    console.log(p.test('q@a.qq.com'));//true

捕获

  括号不仅仅可本着素举办分组,还相会保留每个分组匹配的文本,等到匹配完后,引用捕获的内容。因为捕获了文本,这种效益让捕获分组

  比如,要配合诸如2016-06-23如此的日子字符串

/(\d{4})-(\d{2})-(\d{2})/

  同往常异之是,年、月、日即四个数值被括号括起来了,从左到右为第1只括号、第2只括号和第3独括号,分别代表第1、2、3单捕获组

  javascript有9个用于存储捕获组的构造函数属性

RegExp.$1\RegExp.$2\RegExp.$3……到RegExp.$9分别用于存储第一、第二……第九个匹配的捕获组。在调用exec()或test()方法时,这些属性会被自动填充

console.log(/(\d{4})-(\d{2})-(\d{2})/.test('2016-06-23'));//true
console.log(RegExp.$1);//'2016'
console.log(RegExp.$2);//'06'
console.log(RegExp.$3);//'23'
console.log(RegExp.$4);//''

  而exec()方法是专门为捕获组而规划之,重回的数组中,第一件是与所有格局匹配的字符串,其他项是暨模式面临之捕获组匹配的字符串

console.log(/(\d{4})-(\d{2})-(\d{2})/.exec('2016-06-23'));//["2016-06-23", "2016", "06", "23"]

  捕获分组捕获的文书,不仅可用于数据提取,也可用来替换

  replace()方法就是是用以开展数据替换的,该方法接收五个参数,第一单参数为用搜的情,而第二个参数为轮换的内容

console.log('2000-01-01'.replace(/-/g,'.'));//2000.01.01

  于replace()方法中呢可引用分组,形式是$num,num是对准承诺分组的数码

//把2000-01-01的形式变成01-01-2000的形式
console.log('2000-01-01'.replace(/(\d{4})-(\d{2})-(\d{2})/g,'$3-$2-$1'));//'01-01-2000'

反向引用

  英文中多单词都暴发重叠出现的假名,如shoot或beep。若想检查有单词是否含有重叠出现的假名,则需引入反向引用(back-reference)

  反为引用允许在正则表达式内部引用前捕获分组匹配的文件,形式是\num,num表示所引用分组的数码

//重复字母
/([a-z])\1/
console.log(/([a-z])\1/.test('aa'));//true
console.log(/([a-z])\1/.test('ab'));//false

  反朝引用得用来建内外联系。HTML标签的开头标签和终结标签是呼应之

//开始标签
<([^>]+)>
//标签内容
[\s\S]*?
//匹配成对的标签
/<([^>]+)>[\s\S]*?<\/\1>/

console.log(/<([^>]+)>[\s\S]*?<\/\1>/.test('<a>123</a>'));//true
console.log(/<([^>]+)>[\s\S]*?<\/\1>/.test('<a>123</b>'));//false

非捕获

  除了捕获分组,正则表明式还提供了非捕获分组(non-capturing
group),以(?:)的款型表示,它只是用于限定效率范围,而非抓获任何文件

  比如,要匹配abcabc这多少个字符,一般地,可以形容吗(abc){2},但鉴于并不需要捕获文本,只是限定了量词的打算范围,所以应写吗(?:abc){2}

console.log(/(abc){2}/.test('abcabc'));//true
console.log(/(?:abc){2}/.test('abcabc'));//true

  由于非捕获分组不抓获文本,对应地,也固然不曾捕获组编号

console.log(/(abc){2}/.test('abcabc'));//true
console.log(RegExp.$1);//'abc'
console.log(/(?:abc){2}/.test('abcabc'));//true
console.log(RegExp.$1);//''

  非捕获分组也无得以接纳反向引用

/(?:123)\1/.test('123123');//false
/(123)\1/.test('123123');//true

  捕获分组和不捕获分组可以以一个正则表明式中而出现

console.log(/(\d)(\d)(?:\d)(\d)(\d)/.exec('12345'));//["12345", "1", "2", "4", "5"]

 

选择

  竖线’|’在正则表达式中表示或(OR)关系的采用,以竖线’|’分隔开之三个子表明式也为选用分或采用项。在一个拣结构面临,选取分的数目没有范围

  在甄选结构中,竖线|用来分隔接纳项,而括号()用来确定任何选取结构的克。假使没起括号,则拿全部表达式视为一个选项结构

  接纳项之品匹配次序是从错误到右手,直到发现了配合配项,假如某个选项项匹配就大意左侧其他选项项,假如所有子采用项都不匹配,则整个选拔结构分外失利

console.log(/12|23|34/.exec('1'));//null
console.log(/12|23|34/.exec('12'));//['12']
console.log(/12|23|34/.exec('23'));//['23']
console.log(/12|23|34/.exec('2334'));//['23']

  ip地址一般由3独点号和4段数字构成,每段数字还于0-255中间

(00)?\d; //0-9
0?[1-9]\d;//10-99
1\d{2};//100-199
2[0-4]\d;//200-249
25[0-5];//250-255
//数字(0-255)
/(00)?\d|0?[1-9]\d|1\d{2}|2[0-4]\d|25[0-5]/;

//ip地址
var ip = /^(((00)?\d|0?[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])\.){3}\2$/;
console.log(ip.test('1.1.1.1'));//true
console.log(ip.test('1.1.1'));//false
console.log(ip.test('256.1.1.1'));//false

  类似地,时间分外也需分段处理

//月(1-12)
0?\d|1[0-2]
//日(1-31)
0?\d|[12]\d|3[01]
//小时(0-24)
0?\d|1\d|2[0-4]
//分钟(0-60)
0?\d|[1-5]\d|60

  手机号一般是11各样,前3各种是号段,后8各一般没限定。而且,在手机起首很可能有0或+86

//开头
(0|\+86)?
//前3位
13\d|14[579]|15[0-35-9]|17[0135-8]|18\d
//后8位
\d{8}

//手机号码
var phone = /(0|\+86)?(13\d|14[579]|15[0-35-9]|17[0135-8]|18\d)\d{8}/;
console.log(phone.test('13453250661'));//true
console.log(phone.test('1913250661'));//false
console.log(phone.test('1345325061'));//false

  以选结构面临,应该尽量避免选用分中是重新匹配,因为这么汇合大大扩充回溯的总计量

//不良的选择结构
a|[ab]
[0-9]|\w

 

断言

  以正则表明式中,有些结构并无确匹配文本,而就承担判断在某某地方左/左边是否符合要求,这种社团于称作断言(assertion),也称之为锚点(anchor),常见的断言有3种植:单词边界、行起首结尾、环视

单词边界

  以文本处理中或许会师时举办单词替换,比如将row替换成line。可是,假诺一向沟通,不仅所有单词row都于交换成line,单词里的row也会叫轮换成line。要想念解决之题目,必须来点子确定单词row,而无是字符串row

  为了缓解就仿佛问题,正则表明式提供了专用的单词边界(word
boundary),记否\b,它非凡的凡’单词边界’地方,而休是字符。\b匹配的凡单方面是但是词字符\w,一边是非单词字符\W的位置

  与\b对承诺之还有\B,表示非单词边界,但实则\B很少使

console.log(/\ban\b/.test('an apple'));//true
console.log(/\ban\b/.test('a an'));//true
console.log(/\ban\b/.test('an'));//true
console.log(/\ban\b/.test('and'));//false
console.log(/\ban\b/.test('ban'));//false

初始结束

  常见的预言还有^和$,它们分别匹配字符串的上马地方及得了地方,所以可以就此来判定任何字符串能否由表明式匹配

//匹配第一个单词
console.log(/^\w*/.exec('first word\nsecond word\nthird word'));//['first']
//匹配最后一个单词
console.log(/\w*$/.exec('first word\nsecond word\nthird word'));//['word']

console.log(/^a$/.test('a\n'));//false
console.log(/^a$/.test('a'));//true

  ^和$的常用效用是剔除字符串首尾多余的空,类似于字符串String对象的trim()方法

function fnTrim(str){
    return str.replace(/^\s+|\s+$/,'')
}  
console.log(fnTrim('      hello world   '));//'hello world'

环视

  环视(look-around),可像地讲吗平息在原地,四处张望。环视类似于才词边界,在她边缘的文本需要满意某种条件,而且我不兼容任何字符

  环视分为正序环视和逆序环视,而javascript只帮忙正序环视,卓殊给仅仅帮助上看,不协理为重放

  而正序环视又分为自然正序环视和否定正序环视

  肯定正序环视的记法是(?=n),表示前必须是n才匹配;否定正序环视的记念法是(?!n),表示前必须不是n才匹配

console.log(/a(?=b)/.exec('abc'));//['a']
console.log(/a(?=b)/.exec('ac'));//null
console.log(/a(?!b)/.exec('abc'));//null
console.log(/a(?!b)/.exec('ac'));//['a']

console.log(/a(?=b)b/.exec('abc'));//['ab']

  [注意]围观尽管也用到括号,却与捕获型分组编号无关;但假使环视结构出现捕获型括号,则会影响分组

console.log(/ab(?=cd)/.exec('abcd'));['ab']
console.log(/ab(?=(cd))/.exec('abcd'));['ab','cd']

 

分外形式

  匹配格局(match
mode)指匹配时使用的规则。设置一定的情势,可能会面转移对正则表明式的识别。前边都介绍过创制正则表明式对象时,能够设置’m’、’i’、’g’这两只标志,分别指向承诺多举行情势、不分轻重缓急形式以及大局情势二种

i

  默认地,正则表明式是分轻重缓急写的,通过安装标志’i’,可以忽略大小写(ignore
case)

console.log(/ab/.test('aB'));//false
console.log(/ab/i.test('aB'));//true

m

  默认地,正则表明式中的^和$匹配的是通字符串的发端位置及了地点,而经设置标志’m’,开启多执行模式,它们为可以匹配配字符串内部有一样实践文本的起首地方及了结地方

console.log(/world$/.test('hello world\n')); //false
console.log(/world$/m.test('hello world\n')); //true

console.log(/^b/.test('a\nb')); //false
console.log(/^b/m.test('a\nb')); //true

g

  默认地,第一糟匹配成功后,正则对象就终止往下匹配了。g修饰符表示全局匹配(global),设置’g’标志后,正则对象将非常全体符合条件的结果,首要用以搜索和替换

console.log('1a,2a,3a'.replace(/a/,'b'));//'1b,2a,3a'
console.log('1a,2a,3a'.replace(/a/g,'b'));//'1b,2b,3b'

 

优先级

  正则表明式千变万化,都是由于前介绍过的字符组、括号、量词等为主构造组合而成的

//从上到下,优先级逐渐降低
\                            转义符
() (?!) (?=) []              括号、字符组、环视
* + ? {n} {n,} {n,m}         量词
^ $                          起始结束位置
|                            选择

  由于括号的用处之一就是是啊量词限定效能范围,所以先级比量词高

console.log(/ab{2}/.test('abab'));//false
console.log(/(ab){2}/.test('abab'));//true

  [注意]择符’|’的优先级最低,比起初与了地点还设小

console.log(/^ab|cd$/.test('abc'));//true
console.log(/^(ab|cd)$/.test('abc'));//false

 

局限性

  虽然javascript中的正则表明式功用于全,但同其它语言相比较,缺乏某些特征

  下面列有了javascript正则表明式不协理之性状

  【1】POSIX字符组(只辅助一般字符组和排除型字符组)

  【2】Unicode帮忙(只扶助单个Unicode字符)

  【3】匹配字符串起先跟终极的\A和\Z锚(只支持^和$)

  【4】逆序环视(只帮忙顺序环视)

  【5】命名分组(只援助0-9号码的捕获组)

  【6】单行形式以及注释模式(只扶助m、i、g)

  【7】形式图范围

  【8】纯文本情势

参考资料

【1】 阮一峰Javascript标准参照教程——标准库RegExp对象
http://javascript.ruanyifeng.com/stdlib/regexp.html
【2】《正则指导》
【3】《了解正则表明式》
【4】《javascript权威指南(第6版)》第10段 正则表明式的形式匹配
【5】《javascript高级程序设计(第3本)》第5节 引用类型
【6】《javascript语言出色(修订版)》第7回 正则表达式