Summarize the creation and use of regular expressions in js

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

正则表达式的创建

两种方法，一种是直接写，由包含在斜杠之间的模式组成；另一种是调用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", index: 0, input: "123abc"]/\d+?/.exec('123abc')            // ["1", index: 0, 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", index: 0, input: "foo"]'foo'.match(/(?:foo){1,2}/)            // ["foo", index: 0, input: "foo"]'foofoo'.match(/(?:foo){1,2}/)         // ["foofoo", index: 0, input: "foofoo"]'foofoo'.match(/foo{1,2}/)             // ["foo", index: 0, input: "foofoo"]

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

x(?=y), x(?!y), x|y 

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

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

x|y: 匹配x或y

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

例子：

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

{n}, {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", index: 1, input: "caaandy"]/a{1,3}/.exec('candy')       // ["a", index: 1, input: "candy"]/a{1,3}/.exec('caandy')      // ["aa", index: 1, input: "caandy"]/a{1,3}/.exec('caaandy')     // ["aaa", index: 1, input: "caaandy"]/a{1,3}/.exec('caaaandy')    // ["aaa", index: 1, input: "caaaandy"]

[xyz], [^xyz] 

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

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

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

例：

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

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

其他

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

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

例子：

    /\bm/.exec('moon')            　　　　　  　// ["m", index: 0, input: "moon"]/\bm/.exec('san moon')      　　　　　　    // ["m", index: 4, input: "san moon"]/oo\b/.exec('moon')           　　　　　　  // null/\B../.exec('noonday')                    // ["oo", index: 1, input: "noonday"]/y\B../.exec('possibly yesterday')        // /y\B../.exec('possibly yesterday')

\d: Matches a number, equivalent to [0-9];

\D: Matches a non-numeric character, equivalent to [^0-9];

\f: Matches a form feed character (U+000C);

\n: Matches a line feed character (U+000A);

\r: Matches a carriage return character (U+ 000D);

\s: Matches a whitespace character, including space, tab, form feed and newline, equivalent to [ \f\n\r\t\v\u00a0\u1680\ u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff];

\S: Matches a non-whitespace character, equivalent to [^ \f\n \r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff];

\w: Matches a single character (letters, numbers or underscores), equivalent to [A-Za-z0-9_];

\W: matches a non-single-word character, equivalent to [^ A-Za-z0-9_];

Regular expression flags

g: Global search;

i: Case-insensitive;

m: multi-line search;

Use regular expressions

RegExp has exec() and test() methods;

The results of exec matching are: matching results, Capture results, index and input.

The matching result of test is true or false, which is more efficient than exec.

String has match(), replace(), search(), and split() methods;

The matching result of match is the same as RegExp's exec, replace replaces according to the regular expression, and search searches so Position, split splits the string according to the regular expression.

Among them, when replace has a function, the parameter description is as follows:

* Matching items
* Memory items (items in brackets)
* ...
* Matching index
* input item

The above is the detailed content of Summarize the creation and use of regular expressions in js. For more information, please follow other related articles on the PHP Chinese website!