Résumer la création et l'utilisation d'expressions régulières en 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 : correspond à un nombre, équivalent à [0-9] ;

D : correspond à un caractère non numérique, équivalent à [^0-9] ;

f : correspond à un caractère de saut de page (U+000C) ;

n : correspond à un caractère de saut de ligne (U+000A) ;

r : correspond à un caractère de retour chariot (U+000D) ; >

s : correspond à un caractère d'espacement, y compris l'espace, la tabulation, le saut de page et le caractère de nouvelle ligne, équivalent à [fnrtvu00a0u1680u180eu2000-u200au2028u2029u202fu205fu3000ufeff] ;

S : correspond à un caractère autre qu'un espacement, équivalent à In

 ; fnrtvu00a0u1680u180eu2000-u200au2028u2029u202fu205fu3000ufeff[^ ]；

w : correspond à un caractère unique (lettre, chiffre ou trait de soulignement), équivalent à

[A-Za-z0-9_]；

W : correspond à un caractère autre qu'un seul caractère, équivalent à

[^A-Za-z0-9_]；

drapeaux regex

g : recherche globale

i : insensible à la casse

m : recherche multiligne

Les expressions régulières utilisent

RegExp a les méthodes exec() et test()

les résultats de correspondance exec sont : les résultats de correspondance, les résultats de capture, l'index et l'entrée.

Le résultat correspondant du test est vrai ou faux, ce qui est plus efficace que exec.

String a les méthodes match(), replace(), search() et split() ;

Le résultat de la correspondance est le même que celui de l'exécutable de RegExp, remplace le remplacement selon l'expression régulière, et la recherche recherche donc Position, split divise la chaîne en fonction de l'expression régulière.

Parmi eux, lorsque replace a une fonction, la description du paramètre est la suivante :

* élément correspondant

* élément mémoire (élément entre parenthèses)
* ...
* Indice de correspondance
* élément d'entrée

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!