深入浅析js中的正则表达式

发布时间：2020-12-13 20:48:38 所属栏目：百科来源：网络整理

导读：阅读目录正则表达式的创建正则表达式中的特殊字符 (反斜杠) ^ $ *, +, .(小数点) (问号) (x) (:x) x(=y),x(!y),x|y {n},{n,m}: [xyz],[^xyz] 其他正则表达式标志正则表达式使用很多时候多会被正则表达式搞的晕头转向，最近抽出时间对正则表达式进行了

阅读目录

正则表达式的创建
正则表达式中的特殊字符
(反斜杠)
^
$
*, +, .(小数点)
? (问号)
(x)
(?:x)
x(?=y),x(?!y),x|y
{n},{n,m}:
[xyz],[^xyz]
其他
正则表达式标志
正则表达式使用

很多时候多会被正则表达式搞的晕头转向，最近抽出时间对正则表达式进行了系统的学习，整理如下：

正则表达式的创建

两种方法，一种是直接写，由包含在斜杠之间的模式组成；另一种是调用RegExp对象的构造函数。

两种方法的创建代码如下：

// 直接创建
const regex1 = /ab+c/;
const regex2 = /^[a-zA-Z]+[0-9]*W?_$/gi;
// 调用构造函数
const regex3 = new RegExp('ab+c');
const regex4 = new RegExp(/^[a-zA-Z]+[0-9]*W?_$/,"gi");
const regex5 = new RegExp('^[a-zA-Z]+[0-9]*W?_$','gi');

可以看出，调用RegExp构造函数创建正则表达式时，第一个参数可以是字符串，也可以是直接创建的正则表达式。

需要注意的是：RegExp实例继承的toLocaleString()和toString)()方法都会返回正则表达式的字面量，与创建正则表达式的方式无关

例如：

const ncname = '[a-zA-Z_][w-.]*';
const qnameCapture = '((?:' + ncname + ':)?' + ncname + ')';
const startTagOpen = new RegExp('^<' + qnameCapture);
startTagOpen.toString();    // '/^<((?:[a-zA-Z_][w-.]*:)?[a-zA-Z_][w-.]*)/'

正则表达式中的特殊字符

(反斜杠)

1.在非特殊字符前加反斜杠表示下一个字符是特殊的；

2.将其后的特殊字符转译为字面量；

注意：在使用RegExp构造函数时要将转译，因为在字符串里也是转译字符

1.匹配输入的开始；

2.在[]中的第一位时表示反向字符集；

例子：

/^A/.exec('an A')    // null
/^A/.exec('An E')    // ["A",index: 0,input: "An E"]

匹配输入的结束

/t$/.exec('eater')    // null
/t$/.exec('eat')     // ["t",index: 2,input: "eat"]
*,+,.(小数点)

*：匹配前一个表达式0次或多次。等价于 {0,}；

+：匹配前面一个表达式1次或者多次。等价于 {1,}；

.：

匹配除换行符之外的任何单个字符；

? (问号)

1.匹配前面一个表达式0次或者1次。等价于 {0,1}；

2.如果紧跟在任何量词 * + ? {} 的后面，将会使量词变为非贪婪的（匹配尽量少的字符），和缺省使用的贪婪模式正好相反；

3.运用于先行断言

例子：

/d+/.exec('123abc')    　　　// ["123",input: "123abc"]
/d+?/.exec('123abc')      // ["1",input: "123abc"]

(x)

匹配 'x' 并且记住匹配项，括号表示捕获括号；

例子：

/(foo) (bar) 1 2/.test('bar foo bar foo');  // false
/(bar) (foo) 1 2/.test('bar foo bar foo');  // true
/(bar) (foo) 1 2/.test('bar foo');      // false
/(bar) (foo) 1 2/.test('bar foo foo bar');  // false
/(bar) (foo) 2 1/.test('bar foo foo bar');  // true
'bar foo bar foo'.replace( /(bar) (foo)/,'$2 $1' );  // "foo bar bar foo"

模式 /(foo) (bar) 1 2/ 中的 '(foo)' 和 '(bar)' 匹配并记住字符串 "foo bar foo bar" 中前两个单词。模式中的 1 和 2 匹配字符串的后两个单词。

注意：1、2、n 是用在正则表达式的匹配环节，在正则表达式的替换环节，则要使用像 $1、$2、$n 这样的语法。例如，'bar foo'.replace( /(...) (...)/,'$2 $1' )。

(?:x)

匹配 'x' 但是不记住匹配项，这种叫作非捕获括号；

例子：

'foo'.match(/foo{1,2}/)        // ["foo",input: "foo"]
'foo'.match(/(?:foo){1,2}/)      // ["foo",input: "foo"]
'foofoo'.match(/(?:foo){1,2}/)     // ["foofoo",input: "foofoo"]
'foofoo'.match(/foo{1,2}/)       // ["foo",input: "foofoo"]

使用场景：示例表达式 /(?:foo){1,2}/。如果表达式是 /foo{1,2}/，{1,2}将只对 ‘foo' 的最后一个字符 'o‘ 生效。如果使用非捕获括号，则{1,2}会匹配整个 ‘foo' 单词。

x(?=y),x|y

x(?=y)：匹配'x'仅仅当'x'后面跟着'y'；

x(?!y)：匹配'x'仅仅当'x'后面不跟着'y'；

x|y: 匹配x或y

这两种匹配的结果都不包含y

例子：

'JackSprat'.match(/Jack(?=Sprat)/)      // ["Jack",input: "JackSprat"]
'JackWprat'.match(/Jack(?=Sprat)/)      // null
'JackWprat'.match(/Jack(?=Sprat|Wprat)/)  // ["Jack",input: "JackWprat"]
/d+(?!.)/.exec("3.141")    // ["141",input: "3.141"]

{n},m}:

{n}：匹配了前面一个字符刚好发生了n次；

{n,m}：匹配前面的字符至少n次，最多m次。如果 n 或者 m 的值是0，这个值被忽略；

例子：

  /a{2}/.exec('candy')     // null
  /a{2}/.exec('caandy')    // ["aa",index: 1,input: "caandy"]
  /a{2}/.exec('caaandy')    // ["aa",input: "caaandy"]
  /a{1,3}/.exec('candy')    // ["a",input: "candy"]
  /a{1,3}/.exec('caandy')   // ["aa",input: "caandy"]
  /a{1,3}/.exec('caaandy')   // ["aaa",3}/.exec('caaaandy')  // ["aaa",input: "caaaandy"]

[xyz],[^xyz]

[xyz]：一个字符集合。匹配方括号的中任意字符;

[^xyz]：一个反向字符集。匹配任何没有包含在方括号中的字符；

这两种匹配都可以使用破折号（-）来指定一个字符范围，特殊符号在字符集中没有了特殊意义。

例：

function escapeRegExp(string){
  return string.replace(/([.*+?^=!:${}()|[]/])/g,"$&"); 
  //$&表示整个被匹配的字符串
}

例子中的.*+?^=!:${}()都表示字面量，并没有特殊意义。

其他

b：匹配一个词的边界。一个匹配的词的边界并不包含在匹配的内容中。换句话说，一个匹配的词的边界的内容的长度是0；

B：匹配一个非单词边界；

例子：

  /bm/.exec('moon')      　　　　　 　// ["m",input: "moon"]
  /bm/.exec('san moon')   　　　　　　  // ["m",index: 4,input: "san moon"]
  /oob/.exec('moon')      　　　　　　 // null
  /B../.exec('noonday')          // ["oo",input: "noonday"]
  /yB../.exec('possibly yesterday')    // /yB../.exec('possibly yesterday')

d：匹配一个数字，等价于[0-9]；

D：匹配一个非数字字符，等价于[^0-9]；

f：匹配一个换页符 (U+000C)；

n：匹配一个换行符 (U+000A)；

r：匹配一个回车符 (U+000D)；

s：匹配一个空白字符，包括空格、制表符、换页符和换行符，等价于[ fnrtvu00a0u1680u180eu2000-u200au2028u2029u202fu205fu3000ufeff]；

S：匹配一个非空白字符，等价于[^ fnrtvu00a0u1680u180eu2000-u200au2028u2029u202fu205fu3000ufeff]；

w：匹配一个单字字符（字母、数字或者下划线），等价于[A-Za-z0-9_]；

W：匹配一个非单字字符，等价于[^A-Za-z0-9_]；

正则表达式标志

g：全局搜索；

i：不区分大小写；

m：多行搜索；

正则表达式使用

RegExp有exec()和test()方法；

exec匹配的结果为：匹配结果、捕获结果，index和input。

test匹配的结果为true或false，效率比exec要高。

String有match()，replace()，search()，split()方法；

match匹配的结果同RegExp的exec，replace根据正则表达式替换，search查找所以位置，split根据正则表达式分割字符串。

其中，当replace有function时，参数说明如下：

* 匹配项
* 记忆项（括号里面的项）
* ...
* 匹配的index
* input输入项

以上所述是小编给大家介绍的js中的正则表达式，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对编程小技巧网站的支持！

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!