介绍正则表达式中test、exec和match之间的区别以及括号的用法

测试、执行和匹配之间的简单区别

1、测试

测试返回布尔值，以确定相应的字符串中是否有模式。var str=' 1a1b1cvar reg=new RegExp('1 '。 '');alert(reg . test(str))；//真

2、执行

Exec查找并返回当前匹配结果，并将其作为数组返回。var str=' 1a1b1cvar reg=new RegExp('1 '。 '');var arr=reg . exec(str)；如果没有模式，arr为空；否则，arr始终是一个长度为1的数组，其值是当前匹配项。Arr还有三个属性：索引当前匹配的位置；LastIndex当前匹配的结束位置(索引当前匹配的长度)；输入在上面的例子中，输入是str。

exec方法受参数g的影响。如果指定了g，下次调用exec时，搜索将从最后一个匹配的lastIndex开始。var str=' 1a1b1cvar reg=new RegExp('1 '。 '');alert(reg . exec(str)[0])；alert(reg . exec(str)[0])；以上两个输出为1a。现在看一下指定的参数g:varstr=' 1a 1 b1c '；var reg=new RegExp('1 '。' g ')；alert(reg . exec(str)[0])；alert(reg . exec(str)[0])；第一输出1a和第二输出1b。

3、匹配

Match是字符串对象的一种方法。var str=' 1a1b1cvar reg=new RegExp('1 '。 '');alert(str . match(reg))；Match有点像exec，但是：exec是RegExp对象的方法；数学是字符串对象的一种方法。两者还有一个区别，就是参数g的解释，如果指定了参数g，match会一次返回所有结果。var str=' 1a1b1cvar reg=new RegExp('1 '。' g ')；alert(str . match(reg))；//alert(str . match(reg))；//这句话的结果和上一句一样。这个结果是一个有三个元素的数组：1a、1b和1c。

有两种方法可以定义正则表达式对象：

1.第一个定义(构造函数定义):

新的RegExp(模式、属性)；例如，var reg=new RegExp('abc '，' g ')，其中pattern表示表达式内容，上述表示匹配abc

属性：g，全局匹配，I不区分大小写，m执行多行匹配，使用最多的是g和I

2.第二定义(//文本定义):/模式/属性。

例如var reg=/ABC/g；

exec和match之间的详细区别：

1.exec是正则表达式方法，而不是字符串方法，其参数是字符串，如下所示：

如上定义

var reg=new RegExp(' ABC ')；var str='3abc4，5 ab C6 '；reg . exec(str)；2.match是一种字符串执行方法，用于匹配正则表达式规则。它的参数是正则表达式，例如

var reg=new RegExp(' ABC ')；var str='3abc4，5 ab C6 '；str . match(reg)；3.exec和match都返回数组(正则表达式没有子表达式，被定义为非全局匹配)

如果exec执行的正则表达式没有子表达式(括号中的内容，如/abc中的(\s*)/)，如果有匹配，则返回第一个匹配的字符串内容，此时数组中只有一个元素，如果没有匹配，则返回null

var reg=new RegExp(' ABC ')；var str='3abc4，5 ab C6 '；alert(reg . exec(str))；alert(str . match(reg))；执行上面的代码，你会发现两个内容是一样的：abc，

4.如果正则表达式对象定义为全局匹配(正则表达式没有子表达式，定义为全局匹配)

var reg=new RegExp('abc '，' g ')；var str='3abc4，5 ab C6 '；alert(reg . exec(str))；alert(str . match(reg))；然后是abc和abc，ABC；因为match执行了一个全局匹配查询；Exec，如果没有子表达式，只会找到匹配并返回。

5.当表示包含子表达式时(正则表达式有子表达式并被定义为非全局匹配):

var reg=new RegExp(' a(BC)')；var str='3abc4，5 ab C6 '；alert(reg . exec(str))；alert(str . match(reg))；你会发现两个实施的结果都是：abc，BC；

6.当正则表达式对象被定义为全局匹配时(正则表达式有子表达式，被定义为全局匹配)

var reg=new RegExp('a(bc)'，' g ')；var str='3abc4，5 ab C6 '；alert(reg . exec(str))；alert(str . match(reg))；两者返回的结果都是abc，bc和abc，abc，

总结如下：

1.当正则表达式没有子表达式且定义为非全局匹配时，exec和match执行的结果相同，都返回第一个匹配的字符串内容；

2.当正则表达式没有子表达式并且被定义为全局匹配时，执行exec和match。如果有多个匹配的内容，match返回多个元素数组；

3.当正则表达式有子表示且定义为非全局匹配时，exec和match执行的结果与上面第五种情况相同；

4.当正则表达式具有子表示并被定义为全局匹配时，exec和match的结果是不同的。此时match会忽略子表达式，只找到完全匹配的正则表达式并返回所有内容，如上面第六种情况；

也就是说，exec与全局定义无关，match与全局定义相关。当它被定义为非全局时，两者的执行结果是相同的。

任何语言都有括号。正则表达式也是一种语言，括号的存在让这种语言更加强大。

括号是否得心应手，是衡量规律性掌握程度的一个侧面标准。

其实括号的作用三言两语就能说清楚，括号为我们引用提供了分组。

引用组时有两种情况：在JavaScript中引用和在正则表达式中引用。

虽然这篇文章的内容比较简单，但我也想写得更长一些。

内容包括：

1.分组和分支结构

2.捕获数据包

3.反向参考

4.非捕获分组

5.相关案例

1.分组和分支结构

这两个是括号最直观的功能，也是最原始的功能。

1.1分组

我们知道/a/匹配连续的“a”，但是需要/(ab)/来匹配连续的“ab”。

其中，括号提供分组功能，使量词“”整体作用于“ab”，测试如下：

var regex=/(ab)/g；var string='亚的斯亚贝巴abbb ababab '；console . log(string . match(regex))；//['abab '，' ab '，' abab']1.2分支结构

在多选择分支结构(p1|p2)中，括号在这里的作用不言而喻，它提供了子表达式的所有可能性。

例如，匹配以下字符串：

我爱JavaScript我爱正则表达式可以用正则：

var regex=/^I洛夫(javascript |正则表达式)$/；console . log(regex . test(‘我爱JavaScript’))；//true console . log(regex . test(‘我爱正则表达式’))；//true如果去掉正则中的括号，也就是/我爱JavaScript |正则表达式$/，匹配的字符串是‘我爱JavaScript’和‘正则表达式’，这不是我们想要的。

2.参考分组

这是括号的一个重要功能。有了它，我们可以更有力地提取和替换数据。

要使用它带来的好处，您必须一起使用实现环境的API。

以日期为例。假设格式是yyyy-mm-dd，我们可以先写一个简单的正则：

var regex=/\ d { 4 }-\ d { 2 }-\ d { 2 }/；然后将其修改为括号内的版本：

var regex=/(\ d { 4 })-(\ d { 2 })-(\ d { 2 })/；为什么要用这种规律性？

2.1提取数据

例如，要提取年、月和日，您可以这样做：

var regex=/(\ d { 4 })-(\ d { 2 })-(\ d { 2 })/；var string=' 2017-06-12 '；console . log(string . match(regex))；//=['2017-06-12 '，' 2017 '，' 06 '，' 12 '，索引： 0，输入：' 2017-06-12']一个match返回的数组，第一个元素是整体匹配结果，然后是每个组(在括号中)(注意：如果正则有一个修饰符g，则match返回的数组的格式是不同的。).

您也可以使用常规对象的exec方法：

var regex=/(\ d { 4 })-(\ d { 2 })-(\ d { 2 })/；var string=' 2017-06-12 '；console . log(regex . exec(string))；//=['2017-06-12 '，' 2017 '，' 06 '，' 12 '，索引： 0，输入：' 2017-06-12']同时，还可以使用构造函数的全局属性$1到$9来获取：

var regex=/(\ d { 4 })-(\ d { 2 })-(\ d { 2 })/；var string=' 2017-06-12 '；regex.test(字符串)；//常规操作，如//regex . exec(string)；//string . match(regex)；console.log(RegExp。$1);//'2017'console.log(RegExp。$2);//'06'console.log(RegExp。$3);//'12'2.2更换

例如，如何将yyyy-mm-dd格式替换为mm/dd/yyyy？

var regex=/(\ d { 4 })-(\ d { 2 })-(\ d { 2 })/；var string=' 2017-06-12 '；var result=string.replace(regex，' $ 2/$ 3/$ 1 ')；console.log(结果)；//'06/12/2017 '，其中第二个参数中使用了$1、$2和$3来引用对应的分组。相当于以下形式：

var regex=/(\ d { 4 })-(\ d { 2 })-(\ d { 2 })/；var string=' 2017-06-12 '；var result=string.replace(regex，function() { return RegExp。$2 '/' RegExp。$3 '/' RegExp。$1;});console.log(结果)；//'06/12/2017 '也相当于：

var regex=/(\ d { 4 })-(\ d { 2 })-(\ d { 2 })/；var string=' 2017-06-12 '；var result=string.replace(regex，function(match，year，month，day){ return month '/day '/year；});console.log(结果)；//'06/12/2017'3.反向参考

除了使用相应的API引用分组之外，还可以引用正则表达式本身中的分组。但是，您只能引用前面的分组，即反向引用。

以日期为例。

例如，编写一个常规支持来匹配以下三种格式：

2016-06-122016/06/122016.06.12

你可能想到的第一个规律是：

var regex=/\d{4}(-|\/|\。)\d{2}(-|\/|\。)\ d { 2 }/；var string 1=' 2017-06-12 '；var string 2=' 2017/06/12 '；var string 3=' 2017 . 06 . 12 '；var string 4=' 2016-06/12 '；console . log(regex . test(string 1))；//true console . log(regex . test(string 2))；//true console . log(regex . test(string 3))；//true console . log(regex . test(string 4))；//true where/and。需要逃脱。虽然符合要求，但也符合‘2016-06/12’的数据。

如果我们希望分隔符保持一致呢？此时需要反向引用：

var regex=/\d{4}(-|\/|\。)\ d { 2 } \ 1 \ d { 2 }/；var string 1=' 2017-06-12 '；var string 2=' 2017/06/12 '；var string 3=' 2017 . 06 . 12 '；var string 4=' 2016-06/12 '；console . log(regex . test(string 1))；//true console . log(regex . test(string 2))；//true console . log(regex . test(string 3))；//true console . log(regex . test(string 4))；//false请注意内部的\1，它表示(-| \/| \)引用之前的分组。).不管它匹配什么(如-)，\1都匹配相同的特定字符。

我们知道了\1的含义后，就理解了\2和\3的概念，即分别指第二组和第三组。

看到这里，这个时候，恐怕你会有三个疑问。

3.1如果括号是嵌套的呢？

以左括号(开括号)为准。例如：

var regex=/^((\d)(\d(\d)))\1\2\3\4$/；var字符串=' 1231231233 '；console . log(regex . test(string))；//trueconsole.log(RegExp。$1 );//123console.log(RegExp。$2 );//1console.log(RegExp。$3 );//23console.log(RegExp。$4 );//3我们可以看看这个规则匹配模式：

第一个字符是一个数字，如1。

第二个字符是一个数字，如2。

第三个字符是数字，如3。

接下来是\1，这是第一个分组内容，看第一个左括号对应的分组，是123。

接下来是\2，找到第二个左括号，对应分组，匹配内容是1，

接下来是\3，找到第三个左括号，对应的分组，匹配的内容是23，

最后一个是\4，找到第三个左括号，对应的分组，匹配的内容是3。

估计这个问题仔细一看就明白了。

3.2 \10是什么意思？

另一个问题可能是，\10是第十组，还是\1和0？答案是前者，虽然常规中很少出现\10。测试如下：

var regex=/(1)(2)(3)(4)(5)(6)(7)(8)(9)(#)\ 10/；var string=' 123456789 # # # # # # # ' console . log(regex . test(string))；3.3引用不存在的分组会怎么样？

因为反向引用是指前面的分组，但是当我们引用正则表达式中不存在的分组时，正则表达式此时不会报错，而只匹配反向引用的字符本身。例如，\2匹配' \2 '。请注意，“\2”表示2已被翻译。

var regex=/\ 1 \ 2 \ 3 \ 4 \ 5 \ 6 \ 7 \ 8 \ 9/；console . log(regex . test(' 1 \ 2 \ 3 \ 4 \ 5 \ 6 \ 7 \ 8 \ 9 ')；console . log(' \ 1 \ 2 \ 3 \ 4 \ 5 \ 6 \ 7 \ 8 \ 9 '。split(“”)；Chrome浏览器打印结果：

4.非捕获分组

上一篇文章中出现的分组将捕获匹配的数据供后续参考，因此它们也被称为捕获分组。

如果只想要括号的原始功能，而不引用，即API中不引用，正则中不反向引用。此时，您可以使用非捕获分组(？p)，例如，本文中的第一个示例可以修改为：

var regex=/(？ ab)/g；var string='亚的斯亚贝巴abbb ababab '；console . log(string . match(regex))；//['abab '，' ab '，' ababab']5。相关案例

至此，括号的功能已经完成。综上所述，它提供了群体供我们使用，如何使用取决于我们自己。

5.1弦修剪方法模拟

Trim方法是删除字符串开头和结尾的空白。有两种方法可以做到。

首先，匹配开头和结尾的空白字符，然后用空白字符替换它们。例如：

函数trim(str){ return str.replace(/^\s | \ s $/g ' ')；} console . log(trim(' foobar ')；//'foobar '其次，匹配整个字符串，然后通过引用提取对应的数据：

功能微调(str) {返回str.replace(/^\s*(.*?)\s*$/g，' $ 1 ')；} console . log(trim(' foobar ')；//“foobar”惰性匹配在这里使用*？否则，它将匹配最后一个空格之前的所有空格。

当然，前者是有效率的。

5.2将每个单词的第一个字母转换为大写

函数title ize(str){ return str . tolowercase()。替换(/(？^|\s)\w/g，函数(c){ return c . touppercase()；});}console.log(titleize('我叫epeli ')；//我叫e peli的想法是找到每个单词的第一个字母。当然，这里不使用非捕获匹配是可以的。

5.3隆起

函数camelize(str){ return str . replace(/[-_ \ s])。)?/g，函数(match，c) { return c？c . touppercase():“”；});} console . log(camelize('-moz-transform ')；moztransform的第一个字母不会转换为大写。组(。)表示第一个字母、单词的定义，前面的字符可以是多个连字符、下划线和空格。常规之后？目的是处理字符串末尾的字符可能不是单词字符的事实，例如，字符串是“-moz-transform”。

5.4划线

函数dash erize(str){ return str . replace(/([A-Z])/g，'-$1 ')。替换(/[-_\s] /g，'-')。toLowerCase()；} console . log(dash erize(' MozTransform ')；//-moz-变换驼峰逆过程。

5.5 html转义和反向含义

//将HTML特殊字符转换为等效的实体函数转义HTML(str){ var escape chars={ ' ' : ' cent '，' :' pound '，' :' yen '，'？': 'euro '，' :'copy '，' : 'reg '，' : 'lt '，' : 'gt '，' : 'quot '，' : 'amp '，' \ ' : ' # 39 ' }；返回字符串替换(新的正则表达式('[' Object.keys(转义字符))。联接(“)”)]”、“g”)、函数(match) { return ' '擒纵字符[match]”；”；});}console.log(擒纵HTMl(' DivBrah blah/div ')；//=div blah blah/div，它使用构造函数生成的正则表达式，然后替换相应的格式，与本文关系不大。

这是它的反向过程，使用括号提供引用，也非常简单，如下所示：

//实体字符转换为等效的HTML。函数UnescapehTMl(str){ var HTMlentities={ nbsp : ' '，cent: ' '，pound: ' '，yen: ' '，euro: '？'copy: ' '，reg: ' '，lt: ' '，gt: ' '，quot: ' '，amp: ' '，apos : ' ' \ ' ' }；返回str.replace(/\([^；] );/g，function(match，key){ if(htmlEntities中的key){ return htmlEntities[key]；}返回匹配；});} console . log(UnescapehTMl(' DivBrah blah/div ')；//=div blah blah/div通过key获取对应的组引用，然后将其作为对象的key。

5.6匹配标签对

需要匹配：

Title正则表达式/titleplaoyao bye bye/p不匹配：

标题错误！/p匹配一个开放标记，可以使用正则[]，

匹配封闭标签，可以使用\/[]，

但是，需要匹配标签对，因此需要使用反向引用，例如：

var regex=/([^])[\ d \ d]* \/\ 1/；var string1=正则表达式/title '；var string 2=' plaoyao bye bye/p '；var string 3=' title error！/p '；console . log(regex . test(string 1))；//true console . log(regex . test(string 2))；//true console . log(regex . test(string 3))；//false将开头的标签[]改为([])，使用括号的目的是为了提供分组，以便向后引用。封闭标签使用反向引用，\/\1。

另外，[\d\D]表示这个字符是不是数字，所以表示匹配任意字符。

摘要

以上是边肖介绍的正则表达式中test、exec和match之间的区别，以及括号的用法。希望对大家有帮助。如果你有任何问题，请给我留言，边肖会及时回复你。非常感谢您对我们网站的支持！