Detaillierte Erläuterung der regulären js-Ausdrücke

Reguläre Ausdrücke sind sehr nützlich zum Suchen, Abgleichen, Verarbeiten von Zeichenfolgen, Ersetzen und Konvertieren von Zeichenfolgen, Ein- und Ausgabe usw. Hier sind einige häufig verwendete reguläre Ausdrücke.

Häufig verwendete reguläre Zeichen

1.: Nächstes Zeichen ändern Markiert als Sonderzeichen, Literalzeichen, Rückverweis oder oktales Escapezeichen. „n“ entspricht beispielsweise dem Zeichen „n“. 'n' entspricht einem Zeilenumbruchzeichen. Die Sequenz '' entspricht „“ und „(“ entspricht „(“.

2.^: entspricht der Eingabezeichenfolge Die Startposition. Wenn die Multiline-Eigenschaft des RegExp-Objekts festgelegt ist, stimmt ^ auch mit der Position nach „n“ oder „r“ überein.

: Entspricht der Endposition Eingabezeichenfolge. Wenn die Multiline-Eigenschaft des RegExp-Objekts festgelegt ist, entspricht $ auch der Position vor „n“ oder „r“. 4.

$: entspricht dem vorherigen Unterausdruck Null oder mehr Mal. Beispielsweise kann zo mit „z“ und „zoo“ usw. übereinstimmen. Gültig in

5 : Entspricht dem vorherigen Unterausdruck einmal oder mehrmals. „zo+“ entspricht „zo“ und „zoo“, aber nicht „z +“ entspricht {1,}.*6.

: Passen Sie den vorherigen Unterausdruck null oder einmal an. ist äquivalent zu {0. ,1}. +7.

: n ist a Nicht-negative ganze Zahl, die n-mal übereinstimmt. o{2}‘ kann nicht mit dem ‚o‘ in „Bob“ übereinstimmen, aber es kann mit den beiden o in „food“ übereinstimmen ?8.

: n ist eine nicht negative ganze Zahl. Beispielsweise kann „o{2,}“ nicht mit „o“ in „Bob“ übereinstimmen es kann mit allen o in „foooood“ übereinstimmen. „o{0,}“ entspricht „o*“. : m und n sind beide nichtnegative Ganzzahlen, wobei n {n}10. stehen darf

: Wenn auf dieses Zeichen unmittelbar ein anderer Begrenzer (*, +, ?, {n}, {n,}, {n,m }) folgt, lautet der Übereinstimmungsmodus Nicht gierig. Der nicht gierige Modus entspricht so wenig wie möglich der gesuchten Zeichenfolge, während der standardmäßige gierige Modus so viel wie möglich mit der gesuchten Zeichenfolge übereinstimmt Übereinstimmung mit einem einzelnen „o“, während „o+“ mit allen „o“ übereinstimmt. {n,}11.

: Entspricht jedem einzelnen Zeichen außer „n“. Um ein beliebiges Zeichen einschließlich „n“ zu finden, verwenden Sie ein Muster wie „[.n]“. {n,m}12.

: Muster abgleichen und diese Übereinstimmung erhalten. Die erhaltenen Übereinstimmungen können aus der generierten Matches-Sammlung abgerufen werden, indem die SubMatches-Sammlung in VBScript oder die $0…$9-Eigenschaften in JScript verwendet werden. Um Klammerzeichen zuzuordnen, verwenden Sie „(“ oder „)“.

13.(?:pattern): stimmt mit dem Muster überein, erhält aber nicht das Übereinstimmungsergebnis, was bedeutet, dass es sich um eine nicht erhaltende Übereinstimmung handelt und nicht für später gespeichert wird verwenden. Dies ist nützlich, wenn Sie das „oder“-Zeichen (|) verwenden, um Teile eines Musters zu kombinieren. Beispielsweise ist „industr(?:y|ies)“ ein kürzerer Ausdruck als „industry|industries“.

14.(?=pattern): Vorwärtssuche, Abgleich der Suchzeichenfolge am Anfang eines beliebigen Zeichenfolgenübereinstimmungsmusters. Dies ist eine Nicht-Abruf-Übereinstimmung, d. h. die Übereinstimmung muss nicht zur späteren Verwendung abgerufen werden. Beispielsweise entspricht „Windows (?=95|98|NT|2000)“ „Windows“ in „Windows 2000“, aber nicht „Windows“ in „Windows 3.1“. Beim Vorabruf werden keine Zeichen verbraucht, d. h. nach einer Übereinstimmung beginnt die Suche nach der nächsten Übereinstimmung unmittelbar nach der letzten Übereinstimmung und nicht nach dem Zeichen, das den Vorabruf enthält.

15.(?!pattern): Negative Suche, entspricht der Suchzeichenfolge am Anfang jeder Zeichenfolge, die nicht mit dem Muster übereinstimmt. Dies ist eine Nicht-Abruf-Übereinstimmung, das heißt, die Übereinstimmung muss nicht zur späteren Verwendung abgerufen werden. Beispielsweise entspricht „Windows (?!95|98|NT|2000)“ „Windows“ in „Windows 3.1“, aber nicht „Windows“ in „Windows 2000“. Beim Vorabruf werden keine Zeichen verbraucht, d. h. nach einer Übereinstimmung beginnt die Suche nach der nächsten Übereinstimmung unmittelbar nach der letzten Übereinstimmung und nicht nach den Zeichen, die den Vorabruf enthalten

16. x|y: Übereinstimmung mit x oder y. Beispielsweise entspricht „z|food“ „z“ oder „food“. '(z|f)ood' entspricht „zood“ oder „food“.

17.[xyz]: Charaktersammlung. Entspricht einem der enthaltenen Zeichen. Beispielsweise entspricht „[abc]“ dem Wort „a“ in „plain“.

18.[^xyz]: Zeichensatz mit negativem Wert. Entspricht jedem Zeichen, das nicht enthalten ist. Beispielsweise entspricht „1“ dem Wort „p“ in „plain“.

19.[a-z]: Zeichenbereich. Entspricht jedem Zeichen innerhalb des angegebenen Bereichs. „[a-z]“ entspricht beispielsweise jedem Kleinbuchstaben im Bereich „a“ bis „z“.

20.[^a-z]: Negativer Zeichenbereich. Entspricht jedem Zeichen, das nicht im angegebenen Bereich liegt. „2“ entspricht beispielsweise jedem Zeichen, das nicht im Bereich „a“ bis „z“ liegt.

21.b: Passen Sie eine Wortgrenze an, also die Position zwischen dem Wort und dem Leerzeichen. Beispielsweise entspricht „erb“ „er“ in „never“, aber nicht „er“ in „verb“.

22.B: Passen Sie Nicht-Wortgrenzen an. „erB“ entspricht „er“ in „verb“, aber nicht in „never“.

23.cx: Entspricht dem durch x angegebenen Steuerzeichen. cM entspricht beispielsweise einem Strg-M- oder Wagenrücklaufzeichen. Der Wert von x muss A-Z oder a-z sein. Andernfalls wird c als wörtliches „c“-Zeichen behandelt.

24.d: Entspricht einem numerischen Zeichen. Entspricht [0-9].

25.D: Entspricht einem nicht numerischen Zeichen. Entspricht 3.

26.f: Entspricht einem Formularvorschub. Entspricht x0c und cL.

27.n: Entspricht einem Zeilenumbruchzeichen. Entspricht x0a und cJ.

28.r: Entspricht einem Wagenrücklaufzeichen. Entspricht x0d und cM.

29.s: Entspricht allen Leerzeichen, einschließlich Leerzeichen, Tabulatoren, Formularvorschüben usw. Entspricht [fnrtv].

30.S: Entspricht jedem Nicht-Leerzeichen. Entspricht 4.

31.t: Entspricht einem Tabulatorzeichen. Entspricht x09 und cI.

32.v: Entspricht einem vertikalen Tabulatorzeichen. Entspricht x0b und cK.

33.w: Entspricht jedem Wortzeichen, einschließlich eines Unterstrichs. Entspricht „[A-Za-z0-9_]“.

34.W: Entspricht jedem Nicht-Wort-Zeichen. Entspricht „5“.

35.xn: Entspricht n, wobei n ein hexadezimaler Escape-Wert ist. Der hexadezimale Escape-Wert muss genau zwei Ziffern lang sein. Beispielsweise entspricht „x41“ „A“. „x041“ entspricht „x04“ und „1“. Die ASCII-Kodierung kann in regulären Ausdrücken verwendet werden.

36.num: Entspricht num, wobei num eine positive ganze Zahl ist. Ein Verweis auf die erhaltene Übereinstimmung. Beispielsweise entspricht „(.)1“ zwei aufeinanderfolgenden identischen Zeichen.

37.n: Identifiziert einen oktalen Escape-Wert oder eine Rückwärtsreferenz. n ist eine Rückwärtsreferenz, wenn vor n mindestens n abgerufene Unterausdrücke stehen. Andernfalls, wenn n eine Oktalzahl (0-7) ist, dann ist n ein oktaler Escape-Wert.

38.nm: Identifiziert einen oktalen Escape-Wert oder eine Rückwärtsreferenz. nm ist eine Rückwärtsreferenz, wenn vor nm mindestens nm erhältliche Unterausdrücke stehen. Wenn vor nm mindestens n steht, dann ist n eine Rückwärtsreferenz, gefolgt vom Literal m. Wenn keine der vorherigen Bedingungen zutrifft und n und m beide Oktalziffern (0-7) sind, stimmt nm mit dem oktalen Escape-Wert nm überein.

39.nml: Wenn n eine Oktalzahl (0-3) ist und m und l beide Oktalzahlen sind ( 0-7), entspricht dem oktalen Escape-Wert nml.

RegExp-Typ

ECMAScript unterstützt reguläre Ausdrücke über den Typ RegExp wie folgt:

var expression = /pattern/flags;

Der Musterteil （pattern） kann ein beliebiger einfacher oder komplexer regulärer Ausdruck sein und Zeichenklassen, Qualifikationsmerkmale, Gruppierungen, Vorwärtssuche und Rückverweise umfassen. Jeder reguläre Ausdruck kann eine oder mehrere Anmerkungen （flags） haben, um das Verhalten des regulären Ausdrucks anzuzeigen. Es gibt drei folgende Zeichen:

• g: Zeigt den globalen Modus an, d. h. der Modus wird auf alle Zeichenfolgen angewendet. Stoppen Sie nicht sofort, wenn die erste Übereinstimmung gefunden wird.

• i: Zeigt den Modus ohne Berücksichtigung der Groß-/Kleinschreibung an.

• m: Zeigt den Mehrzeilenmodus an, d. h. wenn das Ende einer Textzeile erreicht ist, wird weitergefahren Suchen Sie, ob in der nächsten Zeile mit dem Muster übereinstimmende Elemente vorhanden sind.

正则表达式定义方式

以字面量的形式来定义正则表达式

例如：匹配第一个bat或者cat,不区分大小写

var pattern = /[bc]at/i;

使用RegExp构造函数

它接收两个参数：一个是要匹配的字符串模式，另一个是可选的标志字符串。可以使用字面量定义的任何表达式，都可以使用构造函数来定义，还是以上面的例子为例：

var pattern = new RegExp("[bc]at","i");

注意:RegExp构造函数模式参数时字符串，所以再某些情况下要对字符进项双重转义。所有元字符都必须双重转义，如字面量模式为/\[bc\]at/,那么等价的字符串为"/\\[bc\\]at/"

例子：

var re = null,
    i;    for(i=0; i < 10; i++){
        re = /cat/g;
        console.log(re.test("catastrophe"));
    }    for(i=0; i < 10; i++){
        re = new RegExp("cat","g");
        console.log(re.test("catastrophe"));
    }

打印结果都为10个true

正则表达式方法

RegExp对象的exec()方法

该方法是专门为捕获组而设计的，其接受一个参数，即要应用模式的字符串，然后返回包含第一个匹配项信息的数组；或者在没有匹配项的情况下返回null。返回的数组虽然是Array的实例，但是包含两个额外的属性：index和input。其中index表示匹配项在字符串中的位置，而input表示应用字符串表达式的字符串。
例：

var text = "mom and dad and baby";var pattern = /mom( and dad( and baby)?)?/gi;var matches = pattern.exec(text);
console.log(matches.index); 
//0console.log(matches.input); 
//mom and dad and babyconsole.log(matches[0]);    
//mom and dad and babyconsole.log(matches[1]);    
//and dad and babyconsole.log(matches[2]);    
//and baby

对于exec()方法而言，即使在模式中设置了全局标志g，它每次也只是返回一个匹配项。在不设置全局标志的情况下，在同一个字符串上多次调用exec()方法将始终返回第一个匹配项的信息。而在设置全局标志的情况下，每次调用exec()则都会在字符串中继续查找新匹配项，如下例子：

var text = "cat, bat, sat, fat";var pattern1 = /.at/;var matches = pattern1.exec(text);
console.log(matches.index); //0console.log(matches[0]);  //catconsole.log(pattern1.lastIndex); //0matches = pattern1.exec(text);
console.log(matches.index); //0console.log(matches[0]);  //catconsole.log(pattern1.lastIndex); 
//0var pattern2 = /.at/g;var matches = pattern2.exec(text);
console.log(matches.index); //0console.log(matches[0]);  //catconsole.log(pattern2.lastIndex); //3var matches = pattern2.exec(text);
console.log(matches.index); //5console.log(matches[0]);  //batconsole.log(pattern2.lastIndex); //8

注意：IE的JavaScript实现lastIndex属性上存在偏差，即使在非全局模式下，lastIndex属性每次也都在变化。

test()方法

正则表达式常用方法test()，它接受一个字符串参数。在模式与该参数匹配的情况下返回true，否则返回false。
例如：

var text ="000-00-0000";var pattern = /\d{3}-\d{2}-\d{4}/;if(pattern.test(text)){
    console.log('the pattern was matched.');
}

match方法

获取正则匹配到的结果，以数组的形式返回例如：

"186a619b28".match(/\d+/g); 
// ["186","619","28"]

replace方法

replace 本身是JavaScript字符串对象的一个方法，它允许接收两个参数：

replace([RegExp|String],[String|Function])

第1个参数可以是一个普通的字符串或是一个正则表达式.
第2个参数可以是一个普通的字符串或是一个回调函数.

如果第2个参数是回调函数，每匹配到一个结果就回调一次，每次回调都会传递以下参数：

• result: 本次匹配到的结果

• $1,...$9: 正则表达式中有几个()，就会传递几个参数，$1~$9分别代表本次匹配中每个()提取的结果，最多9个

• offset:记录本次匹配的开始位置

• source:接受匹配的原始字符串

以下是replace和JS正则搭配使用的几个常见经典案例：

（1）实现字符串的trim函数，去除字符串两边的空格

String.prototype.trim = function(){ 
  //方式一：将匹配到的每一个结果都用""替换
  return this.replace(/(^\s+)|(\s+$)/g,function(){    return "";
  }); 
  //方式二：和方式一的原理相同
  return this.replace(/(^\s+)|(\s+$)/g,'');
};

^s+ 表示以空格开头的连续空白字符，s+$ 表示以空格结尾的连续空白字符，加上() 就是将匹配到的结果提取出来，由于是 | 的关系，因此这个表达式最多会match到两个结果集，然后执行两次替换：

String.prototype.trim = function(){  /**
   * @param rs：匹配结果
   * @param $1:第1个()提取结果
   * @param $2:第2个()提取结果
   * @param offset:匹配开始位置
   * @param source：原始字符串   */
  this.replace(/(^\s+)|(\s+$)/g,function(rs,$1,$2,offset,source){    //arguments中的每个元素对应一个参数    console.log(arguments);
  });
}; 
" abcd ".trim();

输出结果：

[" ", " ", undefined, 0, " abcd "] 
//第1次匹配结果
[" ", undefined, " ", 5, " abcd "] 
//第2次匹配结果

（2）提取浏览器url中的参数名和参数值，生成一个key/value的对象

function getUrlParamObj(){  var obj = {};  //获取url的参数部分
  var params = window.location.search.substr(1);  //[^&=]+ 表示不含&或=的连续字符，加上()就是提取对应字符串
  params.replace(/([^&=]+)=([^&=]*)/gi,function(rs,$1,$2){
    obj[$1] = $2;
  }); 
  return obj;
}

/([^&=]+)=([^&=]*)/gi 每次匹配到的都是一个完整key/value,形如 <span style="color: #ff0000;">xxxx=xxx</span>, 每当匹配到一个这样的结果时就执行回调，并传递匹配到的key和value，对应到$1和$2

（3）在字符串指定位置插入新字符串

String.prototype.insetAt = function(str,offset){ 
  //使用RegExp()构造函数创建正则表达式
  var regx = new RegExp("(.{"+offset+"})"); 
  return this.replace(regx,"$1"+str);
}; 
"abcd".insetAt('xyz',2); //在b和c之间插入xyz//结果 "abxyzcd"

当offset=2时，正则表达式为：(^.{2}) .表示除\n之外的任意字符，后面加{2} 就是匹配以数字或字母组成的前两个连续字符，加()就会将匹配到的结果提取出来，然后通过replace将匹配到的结果替换为新的字符串，形如：结果=结果+str

（4） 将手机号12988886666转化成129 8888 6666

function telFormat(tel){
 
  tel = String(tel); 
  //方式一
  return tel.replace(/(\d{3})(\d{4})(\d{4})/,function (rs,$1,$2,$3){    return $1+" "+$2+" "+$3
  }); 
  //方式二
  return tel.replace(/(\d{3})(\d{4})(\d{4})/,"$1 $2 $3");
}

(\d{3}\d{4}\d{4}) 可以匹配完整的手机号，并分别提取前3位、4-7位和8-11位，"$1 $2 $3" 是在三个结果集中间加空格组成新的字符串，然后替换完整的手机号。

常用实例

匹配第一个bat或者cat,不区分大小写： <span style="color: #ff0000;">/[bc]at/i</span> 或者 new RegExp("[bc]at","i");

匹配所有以"at"结尾的3个字符组合，不区分大小写：/.at/gi;

只能输入数字：^[0-9]*$;

只能输入n位的数字：^\d{n}$

只能输入至少n位的数字：^\d{n,}$

只能输入m~n位的数字：^\d{m,n}$

只能输入零和非零开头的数字：^(0|[1-9][0-9]*)$

只能输入有两位小数的正实数：^[0-9]+(.[0-9]{2})?$

只能输入有1~3位小数的正实数：^[0-9]+(.[0-9]{1,3})?$

只能输入非零的正整数：^\+?[1-9][0-9]*$

只能输入长度为3的字符：^.{3}$

Es kann nur eine Zeichenfolge eingegeben werden, die aus 26 englischen Buchstaben besteht: ^[A-Za-z]+$

Es kann nur eine Zeichenfolge eingegeben werden, die aus Zahlen und 26 englischen Buchstaben besteht eingegeben werden Eine Zeichenfolge bestehend aus: ^[A-Za-z0-9]+$

Es kann nur eine Zeichenfolge bestehend aus Zahlen, 26 englischen Buchstaben oder Unterstrichen eingegeben werden: ^w+$

Benutzerpasswort überprüfen: beginnt mit einem Buchstaben, ist zwischen 6 und 18 lang und darf nur Zeichen, Zahlen und Unterstriche enthalten: ^[a-zA-Z]w{5,17}$

Überprüfen Sie, ob es Zeichen wie ^%&',;=?$" enthält: [^%&',;=?$x22]+

können nur chinesische Zeichen eingegeben werden: ^[u4e00-u9fa5]{0,}$

E-Mail-Adresse bestätigen: ^w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*$

Internet-URL überprüfen:^http://([w-]+.)+[w-]+(/[w-./?%&=]*)?$

ID-Nummer überprüfen (15 oder 18 Ziffern): ^d{15}|d{18}$

IP-Adresse überprüfen: ^((2[0-4]d|25[0-5]|[01]?dd?).){3}(2[0-4]d|25[0-5]|[01]?dd?)$

Entspricht zwei überlappenden Zeichen, zum Beispiel „aabbc11asd“, die Rückgabe Ergebnis ist aa bb 11 drei Übereinstimmungssätze: (w)1

Übereinstimmung mit gepaarten HTML-Tags: 36f5b8c5490f89f869cc27a69ae2619f[^s>]+)[^>]*>.*942957934194d656236298ebe7d0e760>

Übereinstimmung mit Zahlen zwischen 1 und 58: /^([1-9]|[1-5][0-8])$/

Entspricht einer Ganzzahl zwischen -90 und 90 (einschließlich): ^(-?[1-8][0-9]|-?[1-9]|-?90|0) $

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der regulären js-Ausdrücke. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!