Eine kurze Diskussion über die Verwendung von Regexp -Objekten und Klammern für JS -reguläre Ausdrücke

Schaffung eines Regexp -Objekts:

Die Schaffung regelmäßiger regelmäßiger Ausdrücke kann direkt durchgeführt werden, d. H. Zeichen, die durch Schrägstriche eingeschlossen sind "/". In einer Umgebung, in der Parameteränderungen erforderlich sind, ist der Regexp () -Konstruktor eine bessere Wahl:

var reg1 =/'/w+'/g;

var reg2 = new regexp ('/' // w+/'', 'g');

Wenn Sie die beiden Erstellungsmethoden verglichen, ist der erste Parameter in Regexp die zu erstellende reguläre Zeichenfolge. Einerseits ist es keine direkte Darstellung der Menge, daher ist es nicht mit einem Schrägstrich eingeschlossen. "/"; Stattdessen muss die Zitatmarke "" und dem Fluchtsymbol "/" quadratisch in der Zeichenfolge entkommen sein.

Darüber hinaus wird ein neues Regexp -Objekt generiert und einer Variablen zugewiesen.

Ähnlichkeiten und Unterschiede zwischen Match () und exec ():

Match und EXEC sind häufige Möglichkeiten, um Saiten für reguläre Ausdrücke abzustimmen. Die von den beiden implementierten Funktionen sind ähnlich, mit einigen subtilen Unterschieden:

1. wie man benutzt

Übereinstimmung ist eine Methode zum Wickeln von Objekten mit Zeichenfolgen, Verwendung: String.Match (regexp);

EXEC ist eine Methode eines regulären Ausdrucksobjekts, Verwendung: regexp.exec (String);

2. Ergebnisse zurückgegeben

Wenn Regexp das globale Flag "G" nicht feststellt:

Die Rückgabergebnisse von beiden sind gleich. Das heißt, wenn es keinen übereinstimmenden Wert gibt, gibt es NULL zurück, und wenn es einen übereinstimmenden Wert gibt, gibt es ein Array zurück (lasst uns Array). Array [0] ist eine passende Zeichenfolge, Array [1], Array [2] ... entspricht Substrings, die in regulären Ausdrücken übereinstimmen. Gleichzeitig hat das Array zwei Eigenschaften. Array.Index repräsentiert die Anfangsposition der Matching -Zeichenfolge, und Array.input repräsentiert die abgerufene Zeichenfolge.

Wenn Regexp das globale Flag "G" -Set hat:

Match gibt ein Array -Array zurück, wenn ein Wert vorhanden ist. Jedes Element im Array repräsentiert alle Zeichenfolgen, die übereinstimmen, sodass keine Substrings mehr übereinstimmen. Zu diesem Zeitpunkt hat das Array kein Indexattribut und ein Eingabetattribut.

Exec unterscheidet sich nicht von der Leistung ohne das globale Etikett "G". Das zurückgegebene Array -Array, Array [0], ist die aktuelle Matching -Zeichenfolge, Array [1], Array [2] ... die aktuelle Matching -Zeichenfolge. Achten Sie zu diesem Zeitpunkt auf die letzte Eigenschaft des Regexp -Objekts, die die letzte Position am Ende der Matching -Zeichenfolge in der ursprünglichen Zeichenfolge darstellt. Wenn es kein weiteres Matching -Ergebnis gibt, wird die letzte Eigenschaft auf 0 gesetzt. Daher können Sie die letzte Schleife verwenden, um alle passenden Zeichenfolgen zu finden.

Unterstützen Sie mehrere Matching -Methoden:

JS -Code

 var teststr = "jetzt test001 test002"; var re =/test (/d+)/ig; var r = ""; while (r = re.exec (teststr)) {alert (r [0] + "" + r [1]); }

Außerdem können Sie Teststr.Match (RE) verwenden, aber auf diese Weise gibt es keine Option zu G, und Sie können nur das erste Spiel erhalten.

1. reguläre Ausdrucksregeln

1.1 Normale Zeichen

Buchstaben, Zahlen, chinesische Zeichen, Unterstriche und Interpunktionsmarken, die in den folgenden Kapiteln nicht speziell definiert sind, sind alle "gewöhnliche Zeichen". Wenn ein normaler Zeichen in einem Ausdruck einer Zeichenfolge übereinstimmt, übereinstimmt er dem gleichen Charakter wie er.

Beispiel 1: Wenn der Ausdruck "C", wenn der Zeichenfolge "Abcde" übereinstimmt, ist das Matching -Ergebnis: Erfolg; Der passende Inhalt lautet: "C"; Die passende Position lautet: Starten Sie bei 2 und enden Sie bei 3. (Hinweis: Das Index startet ab 0 oder 1, was je nach aktueller Programmiersprache variieren kann)

Beispiel 2: Wenn der Ausdruck "BCD", wenn der Zeichenfolge "Abcde" übereinstimmt, ist das Matching -Ergebnis: erfolgreich; Der passende Inhalt lautet: "BCD"; Die passende Position ist: Beginnen Sie bei 1 und enden Sie bei 4.

1.2 einfache Fluchtzeichen

Verwenden Sie für einige Zeichen, die unpraktisch zu schreiben sind, die Methode des Hinzufügens "/" zur Vorderseite. Wir sind bereits mit diesen Charakteren vertraut.

Es gibt andere Interpunktionsmarken, die für die Verwendung in den folgenden Kapiteln etwas Besonderes sind. Nach dem Hinzufügen von "/" zur Vorderseite stellen sie das Symbol selbst dar. Zum Beispiel: ^ und $ haben besondere Bedeutungen. Wenn Sie den Zeichen "^" und "$" in einer Zeichenfolge übereinstimmen möchten, muss der Ausdruck als "/^" und "/$" geschrieben werden.

Die passende Methode dieser entkommenen Zeichen ähnelt den "normalen Zeichen". Es entspricht auch dem gleichen Charakter.

Beispiel 1: Wenn der Ausdruck "/$ D", wenn der Zeichenfolge "ABC $ de" übereinstimmt, ist das Matching -Ergebnis: Erfolg; Der passende Inhalt lautet: "$ D"; Die passende Position ist: Beginnen Sie bei 3 und enden Sie bei 5.

1.3 Ausdrücke, die mit 'mehreren Zeichen' übereinstimmen können

Einige Repräsentationsmethoden in regulären Ausdrücken können einem der "Mehrfachzeichen" übereinstimmen. Zum Beispiel kann der Ausdruck "/d" eine beliebige Zahl übereinstimmen. Obwohl es jedem Charakter mithalten kann, kann es nur eins sein, nicht mehrere. Dies ist wie beim Spielen von Pokerkarten können die großen und kleinen Könige jede Karte ersetzen, aber sie können nur eine Karte ersetzen.

Beispiel 1: Wenn der Ausdruck "/d/d", wenn "ABC123" angepasst wird, ist das Match -Ergebnis: Erfolg; Der übereinstimmende Inhalt lautet: "12"; Die übereinstimmende Position ist: Beginnen Sie bei 3 und enden Sie bei 5.

Beispiel 2: Wenn der Ausdruck "A./D", wenn er "AAA100" übereinstimmt, ist das Match -Ergebnis: Erfolg; Der übereinstimmende Inhalt lautet: "AA1"; Die übereinstimmende Position ist: Beginnen Sie bei 1 und enden Sie bei 4.

1.4 Passen Sie Ausdrücke an, die mit den mehreren Zeichen übereinstimmen können

Verwenden Sie quadratische Klammern [], um eine Reihe von Zeichen zu enthalten, die zu jedem übereinstimmen können. Wenn Sie [^] verwenden, um eine Reihe von Zeichen zu enthalten, können Sie einen anderen Charakter als die Zeichen abgleichen. Aus dem gleichen Grund kann es, obwohl es mit jedem von ihnen übereinstimmen kann, nur eins und nicht mehrfach sein.

Beispiel 1: Wenn der Ausdruck "[BCD] [BCD]" Abc123 "übereinstimmt, ist das Match -Ergebnis: Erfolg; Der übereinstimmende Inhalt lautet: "BC"; Die übereinstimmende Position ist: Beginnen Sie bei 1 und enden Sie bei 3.

Beispiel 2: Wenn der Ausdruck "[^abc]" "abc123" übereinstimmt, ist das Match -Ergebnis: Erfolg; Der übereinstimmende Inhalt lautet: "1"; Die übereinstimmende Position ist: Beginnen Sie bei 3 und enden Sie bei 4.

1.5 Sondersymbole, die die Anzahl der Übereinstimmungen ändern

Die im vorherigen Kapitel erwähnten Ausdrücke können nur mit einem Zeichen oder einem von mehreren Zeichen übereinstimmen. Wenn Sie einen Ausdruck sowie ein spezielles Symbol verwenden, das die Anzahl der Übereinstimmungen verändert, können Sie die Übereinstimmung wiederholen, ohne den Ausdruck wiederholt zu schreiben.

Die Methode, es zu verwenden, lautet: "Anzahl der Modifikation" wird nach dem "modifizierten Ausdruck" platziert. Zum Beispiel: "[BCD] [BCD]" kann als "[BCD] {2}" geschrieben werden.

Beispiel 1: Wenn der Ausdruck "/d+/.?/D*" mit "Es kostet $ 12,5", ist das Match -Ergebnis: erfolgreich; Der übereinstimmende Inhalt lautet: "12,5"; Die übereinstimmende Position ist: Beginnen Sie bei 10 und enden Sie bei 14.

Beispiel 2: Wenn der Ausdruck "Go {2,8} Gle" mit "Anzeigen von Gooooogle" übereinstimmt, ist das Match -Ergebnis: Erfolg; Der übereinstimmende Inhalt lautet: "gooooogle"; Die übereinstimmende Position ist: Beginnen Sie bei 7 und enden Sie bei 17.

1.6 Einige andere spezielle Symbole, die eine abstrakte Bedeutung darstellen

Einige Symbole repräsentieren die besondere Bedeutung der Abstraktion in Ausdrücken:

Weitere Textbeschreibungen sind noch relativ abstrakt. Geben Sie daher Beispiele an, um jedem zu verstehen.

Beispiel 1: Wenn der Ausdruck "^aaa" "xxx aaa xxx" übereinstimmt, ist das passende Ergebnis: fehlgeschlagen. Weil "^" angepasst werden muss, wo die Zeichenfolge beginnt, kann "^aaa" nur übereinstimmen, wenn "aaa" am Anfang der Zeichenfolge steht, zum Beispiel: "AAA xxx xxx".

Beispiel 2: Wenn der Ausdruck "AAA $" mit "XXX AAA XXX" übereinstimmt, ist das passende Ergebnis: fehlgeschlagen. Da "$" das Ende der Zeichenfolge übereinstimmt, kann "AAA $" nur dann übereinstimmen, wenn "AAA" am Ende der Zeichenfolge steht, zum Beispiel: "xxx xxx aaa".

Beispiel 3: Wenn der Ausdruck "./b." ist mit "@@@@ abc" übereinstimmt, das Matching -Ergebnis ist: erfolgreich; Der passende Inhalt lautet: "@A"; Die passende Position ist: Beginnen Sie bei 2 und enden Sie bei 4.

Weitere Erläuterung: "/B" ähnelt "^" und "$", die keine Zeichen selbst übereinstimmen, aber es erfordert, dass es sich auf der linken und rechten Seite der Position im passenden Ergebnis befindet. Eine Seite ist die "/w" -Reiche und die andere Seite ist die Nicht-"/W" -Reiche.

Beispiel 4: Wenn der Ausdruck "/Bend/B" übereinstimmt, "Wochenende, Ende, Ende" ist das Matching -Ergebnis: erfolgreich; Der passende Inhalt lautet: "Ende"; Die passende Position ist: Beginnen Sie bei 15 und enden Sie bei 18.

Einige Symbole können die Beziehung zwischen Subexpressionen innerhalb eines Ausdrucks beeinflussen:

Beispiel 5: Wenn der Ausdruck "Tom | Jack" mit der Zeichenfolge "Ich bin Tom, er ist Jack" übereinstimmt, ist das passende Ergebnis: erfolgreich; Der passende Inhalt lautet: "Tom"; Die passende Position ist: Beginnen Sie bei 4 und enden Sie bei 7. Wenn Sie mit dem nächsten zusammenarbeiten, ist das passende Ergebnis: erfolgreich; Der passende Inhalt lautet: "Jack"; Bei der passenden Position: beginnt bei 15 und endet bei 19.

Beispiel 6: Ausdruck "(go/s*)+" Wenn Sie "lass gehen gehen gehen"! Das passende Ergebnis ist: erfolgreich; Der passende Inhalt lautet: "Go Go Go"; Die passende Position ist: Beginnen Sie bei 6 und enden Sie bei 14.

Beispiel 7: Wenn der Ausdruck "￥ (/d+/.?/D*)" "mit" ￥ 10,9, ￥ 20,5 "übereinstimmt, ist das Match -Ergebnis: erfolgreich; Der übereinstimmende Inhalt lautet: "￥ 20,5"; Die übereinstimmende Position ist: Beginnen Sie bei 6 und enden Sie bei 10. Der Inhalt, der die Klassenbereichsübereinstimmung separat erhält, lautet: "20,5".

2. Einige fortgeschrittene Regeln in regulären Ausdrücken

2.1 Gier und Nicht-Greedy in Matchzeiten

Bei Verwendung spezieller Symbole, die die Anzahl der Übereinstimmungen ändern, gibt es mehrere Darstellungsmethoden, die den gleichen Ausdruck ermöglichen, um unterschiedliche Zeiten zu entsprechen, wie z. B. "{m, n}", "{m,}", "?", "?", "*", "+". Die spezifische Anzahl der Übereinstimmungen hängt von der Matching -Zeichenfolge ab. Dieser Ausdruck mit einer unsicheren Anzahl von wiederholten Übereinstimmungen stimmt während des Übereinstimmungsprozesses immer so oft wie möglich überein. Zum Beispiel ist für den Text "dxxxdxxxd" Folgendes:

Es ist ersichtlich, dass wenn "/w+" übereinstimmt, immer so viele Charaktere entspricht, die seine Regeln wie möglich entsprechen. Obwohl es im zweiten Beispiel nicht mit dem letzten "D" übereinstimmt, soll auch der gesamte Ausdruck erfolgreich übereinstimmen. In ähnlicher Weise stimmen Ausdrücke mit "*" und "{m, n}" so viele wie möglich und Ausdrücke mit "?" werden auch so weit wie möglich "übereinstimmen", wenn sie übereinstimmen oder nicht übereinstimmen. Dieses passende Prinzip wird als "Gier" -Muster bezeichnet.

Nicht-Greedy-Modus:

Hinzufügen eines "?" Signieren Sie nach dem Ändern des speziellen Symbols der Anzahl der Übereinstimmungen Ausdrücke mit unterschiedlicher Anzahl von Übereinstimmungen so wenig wie möglich, so dass Ausdrücke, die übereinstimmen oder nicht übereinstimmen können, so weit wie möglich "übereinstimmen" werden können. Dieses passende Prinzip wird als "Nicht-Greedy" -Muster bezeichnet, das auch als "Barb" -Muster bezeichnet wird. Wenn es nur wenige Übereinstimmungen gibt, wird der gesamte Ausdruck fehlschlagen. Ähnlich wie beim Greedy-Modus passt der Nicht-Greedy-Modus minimal, um den gesamten Ausdruck erfolgreich übereinstimmen. Zum Beispiel für den Text "DXXXDXXXD":

Weitere Fälle finden Sie im Folgenden:

Beispiel 1: Wenn der Ausdruck "<td> (.*) </Td>" mit der String übereinstimmt "<td> <p> aa </p> </td> <td> <p> bb </p> </td>" ist das Matching -Ergebnis: Erfolg; Das Match ist "<Td> <p> aa </p> </td>" die gesamte Zeichenfolge, und die "</td>" im Ausdruck stimmt mit dem letzten "</td>" in der Zeichenfolge überein.

Beispiel 2: Im Gegensatz dazu erhalten Sie, wenn der Ausdruck "<td> (.*?) </Td>" in Beispiel 1 derselben Zeichenfolge übereinstimmt, nur "<Td> <p> aa </p> </td>". Wenn Sie wieder mit dem nächsten übereinstimmen, erhalten Sie die zweite "<td> <p> bb </p> </td>".

2.2 Backreferenzen /1, /2 ...

Wenn ein Ausdruck übereinstimmt, zeichnet die Expression Engine die Zeichenfolge auf, die durch den in der Klammer enthaltenen Ausdruck übereinstimmt "()". Beim Erhalten des Matching -Ergebniss kann der in den Klammern enthaltene Ausdruck separat erhalten werden. Dies wurde in den vorherigen Beispielen oft nachgewiesen. In praktischen Anwendungen, wenn eine bestimmte Grenze zur Suche verwendet wird und der zu abgerufene Inhalt keine Grenzen enthält, müssen Klammern verwendet werden, um den gewünschten Bereich anzugeben. Zum Beispiel die vorherige "<td> (.*?) </Td>".

Tatsächlich kann "die String, die durch den in Klammern enthaltenen Ausdruck übereinstimmt", nicht nur nach Ablauf des Spiels verwendet werden, sondern auch während des Übereinstimmungsprozesses. Der Teil nach dem Ausdruck kann sich auf die vorherige "Sub-Match-Zeichenfolge, die in Klammern übereinstimmt" beziehen kann. Die Referenzmethode besteht darin, eine Zahl "/" hinzuzufügen. "/1" bezieht sich auf die in dem erste Paar von Klammern übereinstimmende Zeichenfolge, "/2" bezieht sich auf die in dem zweite Paar von Klammern übereinstimmende Zeichenfolge ... und so weiter, wenn ein Paar Klammern ein weiteres Paar Klammern enthält, werden die Außenklammern zuerst sortiert. Mit anderen Worten, wenn das Paar die linke Klammer hat "(" vorher wird das Paar zuerst sortiert.

Als Beispiel:

Beispiel 1: Der Ausdruck "('|") (.*?) (/1) "Wenn" "Hallo", "Welt" "" abgeht, ist das Match -Ergebnis: erfolgreich; der übereinstimmende Inhalt lautet: "Hallo'". Wenn Sie die nächste vergleichbar sind, können Sie "World" ".

Beispiel 2: Wenn der Ausdruck "(/w)/1 {4,}" mit "AA BBBBBB ABCDEFG CCCCC 111121111 999999999999" übereinstimmt, ist das Match -Ergebnis: erfolgreich; Der übereinstimmende Inhalt ist "CCCCCC". Wenn Sie wieder mit dem nächsten übereinstimmen, erhalten Sie 9999999999. Dieser Ausdruck erfordert Zeichen im Bereich "/w", um mindestens fünfmal wiederholt zu werden, wobei die Differenz von "/w {5,}" achten.

Beispiel 3: Der Ausdruck "<(/w+)/s*(/w+(= ('|").*?/4)?/S*)*>. erfolgreich.

2.3 Voransuchung, Nichtübereinstimmung; Reverse Pre-Scaning, Mismatch

Im vorherigen Kapitel habe ich über mehrere besondere Symbole gesprochen, die abstrakte Bedeutungen darstellen: "^", "$", "/b". Sie alle haben eines gemeinsam: Sie stimmen selbst keine Charaktere überein, sondern fügen nur eine Bedingung an "zwei Enden einer Zeichenfolge" oder "Schlitze zwischen Zeichen" zu. Nach dem Verständnis dieses Konzepts wird dieser Abschnitt weiterhin eine weitere flexiblere Repräsentationsmethode einführen, die "zwei Enden" oder "Schlitze" erhöht.

Voransuchung vorwärts: "(? = Xxxxx)", "(?! Xxxxx)"

Format: "(? = Xxxxx)", in der passenden Zeichenfolge, ist die an den "Schlitz" oder "zwei Enden" angeschlossene Bedingung, dass die rechte Seite des Lückens in der Lage sein muss, den Ausdruck des XXXXXX -Teils zu entsprechen. Da es sich nur um eine zusätzliche Bedingung in dieser Lücke handelt, wirkt es sich nicht auf den nachfolgenden Ausdruck aus, der nach dieser Lücke wirklich mit den Zeichen übereinstimmt. Dies ist ähnlich wie "/B", das keine Charaktere selbst entspricht. "/b" nimmt nur die Charaktere vor und nach der Lücke und fällt ein Urteil und wird die Ausdrücke hinter sich nicht beeinflussen, um wirklich übereinzustimmen.

Beispiel 1: Wenn der Ausdruck "Windows (? = Nt | XP)" mit "Windows 98, Windows NT, Windows 2000" übereinstimmt, stimmt er nur mit "Windows" in "Windows NT" überein, und andere Wörter "Windows" werden nicht übereinstimmen.

Beispiel 2: Ausdruck "(/w) ((? Dieser Ausdruck kann gelesen und interpretiert werden als: Das Wiederholen der alphanumerischen Nummer mehr als das 4 -fache übereinstimmt mit dem Teil vor den letzten 2 Ziffern. Natürlich kann dieser Ausdruck nicht so geschrieben werden, und der Zweck hier ist für Demonstrationszwecke.

Format: "(?! Xxxxx)", die rechte Seite des Spaltes darf nicht mit dem Ausdruck XXXXX übereinstimmen.

Beispiel 3: Ausdruck "((?!/Bstop/b).)+" Wenn "fdjka ljfdl stop fjdsla fdj" angepasst wird, wird es vom Anfang bis zur Position vor "Stop" übereinstimmen. Wenn es in der Zeichenfolge keinen "Stopp" gibt, wird die gesamte Zeichenfolge übereinstimmen.

Beispiel 4: Der Ausdruck "do (?!/W)" kann nur "do" übereinstimmen, wenn sie mit der Zeichenfolge "fertig, do, hund" übereinstimmen. In diesem Artikel ist der Effekt der Verwendung von "Do" nach "(?!/W)" und "/b" gleich.

Reverse Presearch: "(? <= Xxxxx)", "(? <! Xxxxx)"

Die Konzepte dieser beiden Formate ähneln der Voranrechnung. Die Anforderungen für die umgekehrte Vorsuche sind: die "linke Seite" der Lücke. Die beiden Formate erfordern, dass sie in der Lage sein müssen, mit dem angegebenen Ausdruck übereinzustimmen, anstatt die rechte Seite zu beurteilen. Wie "Voranwechslung vorwärts": Sie sind beide eine zusätzliche Bedingung für die Lücke, in der sie sich befinden, und stimmen nicht selbst an die Charaktere überein.

Beispiel 5: Der Ausdruck "(? <=/D {4})/d+(? Da jscript.regexp keine reverse Vorsuche unterstützt, kann dieser Artikel nicht nachgewiesen werden. Viele andere Motoren können die Reverse Pre-Scanes unterstützen, wie z.

3. Andere gemeinsame Regeln

Es gibt auch einige Regeln, die bei verschiedenen regulären Ausdrucksmotoren häufiger vorkommen, die in der vorherigen Erklärung nicht erwähnt wurden.

3.1 In Ausdrücken kann "/xxx" und "/uxxxx" verwendet werden, um ein Zeichen darzustellen ("x" bedeutet eine Hexadezimalzahl).

3.2 Während die Ausdrücke "/s", "/d", "/w", "/b" besondere Bedeutungen darstellen, stellen die entsprechenden Großbuchstaben entgegengesetzte Bedeutungen dar

3.3 Es gibt eine besondere Bedeutung im Ausdruck, und es ist notwendig, "/" der Zeichenzusammenfassung des Charakters selbst hinzuzufügen.

3.4 Unterexpression in Klammern "()". Wenn Sie möchten, dass das Matching -Ergebnis nicht für die zukünftige Verwendung aufgezeichnet wird, können Sie das Format "(?: Xxxxx)" verwenden

Beispiel 1: Wenn der Ausdruck "(?: (/W)/1)+" mit "A bbccdd efg" übereinstimmt, ist das Ergebnis "BBCCDD". Das passende Ergebnis der Klammer "(? :)" Reichweite wird nicht aufgezeichnet, also "(/w)" wird verwendet, um sie zu verweisen.

3.5 Einführung in häufig verwendete Expressionsattributeinstellungen: IgnoreCase, SingleLine, Multiline, Global

4. Andere Tipps

4.1 Wenn Sie verstehen möchten, dass fortgeschrittene reguläre Motoren auch eine komplexe reguläre Syntax unterstützen, finden Sie in der Dokumentation des regulären Deelx -Motors auf dieser Website.

4.2 Wenn Sie den Ausdruck verlangen möchten, dass der gesamte Zeichenfolge übereinstimmt, anstatt einen Teil aus der Zeichenfolge zu finden, können Sie zu Beginn und am Ende des Ausdrucks "^" und "$" verwenden, zum Beispiel: "^/d+$" erfordert, dass die gesamte Zeichenfolge nur Zahlen hat.

4.3 Wenn der zu übereinstimmende Inhalt ein vollständiges Wort und kein Teil des Wortes ist, verwenden Sie "/B" am Anfang und am Ende des Ausdrucks, zum Beispiel: Verwenden Sie "/b(if|

4.4 Der Ausdruck stimmt nicht mit einer leeren Zeichenfolge überein. Andernfalls ist das Match die ganze Zeit erfolgreich und nichts wird übereinstimmen. Zum Beispiel: Wenn Sie sich darauf vorbereiten, einen Ausdruck zu schreiben, der mit "123", "123.", "123.5", ".5" usw. übereinstimmt, können ganze Zahlen, Dezimalpunkte und Dezimalzahlen weggelassen werden, aber schreiben Sie den Ausdruck nicht mit: "/d*/.?/d*", denn wenn es nichts gibt, kann dieser Ausdruck auch nicht erfolgreich mithalten. Ein besserer Weg, es zu schreiben, ist: "/d+/.?/d*|/./d+".

4.5 Schleifen Sie nicht unendlich für Unterpatches, die mit leeren Zeichenfolgen übereinstimmen können. Wenn jeder Teil der Suberpression in den Klammern das 0 -fache übereinstimmen kann und die Klammern als Ganzes unendliche Zeiten übereinstimmen können, kann die Situation schwerwiegender sein als der vorherige Artikel, und der Übereinstimmungsprozess kann ein toter Schleife sein. Obwohl einige reguläre Ausdrucksmotoren die tote Schleife in dieser Situation nun vermieden haben, wie z. B. reguläre Ausdrücke .NET, sollten wir versuchen, diese Situation zu vermeiden. Wenn wir beim Schreiben von Ausdrücken auf eine tote Schleife stoßen, können wir auch aus dieser Sicht starten und herausfinden, ob dies der in diesem Artikel erwähnte Grund ist.

4.6 Wählen Sie vernünftigerweise den Greedy-Modus und den Nicht-Greedy-Modus, siehe Themendiskussion.

4.7 oder "|" Auf der linken und rechten Seite ist es am besten, nur einer Seite eines bestimmten Charakters zu entsprechen, so dass die Ausdrücke auf beiden Seiten von "|" " unterscheidet sich aufgrund der Austauschposition nicht.

Nächster Artikel ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

1. Definieren Sie reguläre Ausdrücke

1) Es gibt zwei Formen der Definition regelmäßiger Ausdrücke, eine ist die gewöhnliche Methode und die andere die Konstruktormethode.

2) Normale Methode: var reg =/expression/zusätzliche Parameter

Ausdruck: Eine Zeichenfolge, die eine bestimmte Regel darstellt, in der bestimmte Sonderzeichen verwendet werden können, um spezielle Regeln darzustellen, die später im Detail erläutert werden.

Zusätzliche Parameter: Zum Erweitern der Bedeutung des Ausdrucks gibt es derzeit drei Hauptparameter:

G: bedeutet, dass globales Matching durchgeführt werden kann.

I: Es bedeutet Fall unempfindlicher Übereinstimmung.

M: bedeutet, dass mehrere Zeilenübereinstimmungen durchgeführt werden können.

Die obigen drei Parameter können willkürlich kombiniert werden, um die zusammengesetzte Bedeutung darzustellen, und natürlich werden keine Parameter hinzugefügt.

Beispiel:

var reg =/a*b/;

var reg =/abc+f/g;

3) Konstruktormethode: var reg = new regexp ("Expression", "Parameter hinzufügen");

Die Bedeutung von "Ausdruck" und "zusätzlichen Parametern" entspricht der obigen Definitionsmethode.

Beispiel:

var reg = neuer regexp ("a*b");

var reg = neuer regexp ("abc+f", "g");

4) Der Unterschied zwischen gewöhnlichen Methoden und Konstruktormethoden

Ein Ausdruck auf normale Weise muss eine konstante Zeichenfolge sein, während der Ausdruck im Konstruktor eine konstante Zeichenfolge oder eine JS -Variable sein kann, z. B. ein Ausdrucksparameter basierend auf der Eingabe des Benutzers usw.:

var reg = new regexp (document.forms [0] .expriled.Value, "g");

2. Ausdrucksmuster

1) Das Expressionsmuster bezieht sich auf die Expressionsmethode und den Stil des Ausdrucks, dh wie man den "Expression" in var reg =/expression/zusätzliche Parameter beschreibt?

2) Aus standardisierter Perspektive werden Expressionsmuster in einfache Muster und zusammengesetzte Muster unterteilt.

3) Einfaches Muster: Bezieht sich auf ein Muster, das zum Beispiel durch die Kombination gewöhnlicher Zeichen ausgedrückt wird

var reg =/abc0d/;

Es ist ersichtlich, dass einfache Muster nur bestimmte Übereinstimmungen darstellen können.

4) Verbundmuster: Bezieht sich auf ein Muster, das mit Platzhalterzeichen ausgedrückt wird, zum Beispiel:

var reg =/a+b?/w/;

Das +,? und /w sind alle Wildcard -Charaktere und repräsentieren besondere Bedeutungen. Daher kann das zusammengesetzte Muster abstraktere Logik ausdrücken.

Konzentrieren wir uns auf die Bedeutung und Verwendung jeder Wildcard im Verbundmodus.

5) Erläuterung von Sonderzeichen im zusammengesetzten Modus:

1>/: Es wird in vielen Programmiersprachen als Fluchtcharakter verwendet. Allgemein gesprochen

Wenn das / Symbol von dem gewöhnlichen Zeichen C gefolgt wird, ist / c eine besondere Bedeutung. Zum Beispiel repräsentiert N ursprünglich das Zeichen n, aber /N repräsentiert eine neue Zeile.

Wenn das / Symbol von einem speziellen Zeichen c folgt, repräsentiert / c das gewöhnliche Zeichen c. Zum Beispiel wird / im Allgemeinen als Fluchtzeichen verwendet, aber // wird verwendet, um das gewöhnliche Zeichen zu stimmen /.

Die Verwendung von / in JavaScripts regulärem Ausdruck ist der gleiche wie oben, aber in verschiedenen Programmiersprachen können spezielle Zeichen Tabellen unterschiedlich sein.

2>^: Übereinstimmung mit dem Beginn der Eingangszeichenfolge. Wenn es sich um eine Multi-Line-Übereinstimmung handelt, dh die zusätzlichen Parameter des Ausdrucks enthalten M, wird es auch nach einer Newline übereinstimmt.

Beispiel:

/^B/pass die erste B in "Bab Bc" überein

Beispiel 2:

/^B/gm Matching

„Badd b

CDAF

B dsfb ”

Die erste Zeile in der ersten B, die erste B in der dritten Zeile

3> $: Passen Sie das Ende der Eingabecharaktererstellung an. Wenn es sich um eine Multi-Line-Übereinstimmung handelt, dh die zusätzlichen Parameter des Ausdrucks enthalten M, wird es auch vor einer Newline übereinstimmt.

Entgegen der Verwendung von ^.

Beispiel: / t $ / Matches t in "BAT", passt aber nicht mit T in "Hass" überein.

Beispiel 2: /t $ /Match

„Tag at

Schläger"

Das letzte t der ersten Zeile und die t der zweiten Zeile.

4>*: Passen Sie das vorherige Zeichen von 0 oder mehrmals an.

Beispiel: /ab* /Matches "AbbBB" in "Dddabbbbc" und passt auch "in" DDDA "überein.

5>+: Passen Sie den vorherigen Charakter 1 oder mehrmals an.

Beispiel: / ab+ / Matches "ABBBB" in "dddabbbbc", entspricht jedoch nicht "ddda".

Ähnlich wie bei der Verwendung der folgenden {1,} (Prototyp: {n,})

6> ?: Die Verwendung von? ist etwas ganz Besonderes. Im Allgemeinen wird es verwendet, um dem vorherigen Charakter 0 -mal oder 1 Mal übereinzustimmen, aber zwei weitere besondere Verwendungen:

Wenn unmittelbar folgt *, +,? und {} bedeutet dies, dass die Mindestanzahl der Übereinstimmungen der ursprünglichen Übereinstimmung beispielsweise:

/ ba*/ ursprünglich "baaaa" in "bbbaaaa" übereinstimmte, aber/ ba*?/ Matched "B" in "bbbaaaa" (weil*0 oder mehr Übereinstimmungen bedeutet, während plus die minimale Anzahl von Übereinstimmungen bedeutet, dh 0 Übereinstimmungen).

Ähnlich: / ba+? / Matches "BA" in "Baaaa".

Als Syntax-Struktursymbol wird es vor dem Assert verwendet, das heißt x (? = Y) und x (?! = Y), um später erwähnt zu werden.

7>.: Das "." Melden Sie sich im Dezimalpunkt an, mit Ausnahme des Newline -Charakters zu einem einzelnen Charakter.

Was sind die Charaktere im Standard insgesamt? Bitte beziehen Sie sich auf: Zeichensatz

Zum Beispiel: / ab / Matches "ACB" in "ACBAA", passt aber nicht mit "AbbB" überein.

8> (x): bedeutet übereinstimmend x (nicht speziell auf das Zeichen x oder speziell auf ein Zeichen bezieht, X repräsentiert eine Zeichenfolge) und das Match wird in Erinnerung bleiben. In der Syntax heißt diese Art von () "Gespüren erfassen Eltern", dh die für die Erfassung verwendeten Klammern.

Übereinstimmungen werden in Erinnerung bleiben, da in den Funktionen, die durch den Ausdruck bereitgestellt werden, einige Funktionen ein Array zurückgeben, das alle passenden Zeichenfolgen enthält, z. B. die Funktion von exec ().

Beachten Sie auch, dass die Prämisse, an die X in () in Erinnerung bleibt, X übereinstimmen soll.

Beispiel 1:

var regx =/a (b) c/;

var rs = regx.exec ("ABCDDD");

Wie aus den oben genannten, / a (b) C / Matches "ABC" in "ABCDDD" ersichtlich ist. Aufgrund von () wird B es auch aufzeichnen, sodass der von RS zurückgegebene Zahleninhalt:

{ABC, B}

Beispiel 2:

var regx =/a (b) c/;

var rs = regx.exec ("acbcddd");

RS kehrt NULL zurück, da / a (b) c / nicht mit "ACBCDDD" übereinstimmt, so dass b in () nicht aufgezeichnet wird (obwohl die Zeichenfolge b enthält)

9> (?: x): Match X, aber erinnere dich nicht an x. () In diesem Format wird als "nicht kennzeichnende Eltern" bezeichnet, dh Klammern für die Nichtabfassung.

Beispiel:

var regx =/a (?: b) c/;

var rs = regx.exec ("ABCDDD");

Wie aus den oben genannten, / a (?: b) c / Matches "ABC" in "ABCDDD", wegen (? :), wird B nicht aufgezeichnet, sodass der von RS zurückgegebene Nummerninhalt:

{ABC}

10> x (? = Y): Übereinstimmung X, nur wenn y sofort befolgt wird. Wenn das Match -Match ist, wird nur X in Erinnerung bleiben und Y wird nicht in Erinnerung bleiben.

Beispiel:

var regx =/user (? = name)/;

var rs = regx.exec ("Der Benutzername ist Mary");

Ergebnis: Die Übereinstimmung ist erfolgreich und der Wert von RS ist {Benutzer}

11> x (?! Y): Match X, nur wenn y nicht sofort befolgt wird. Wenn das Match -Match ist, wird nur X in Erinnerung bleiben und Y wird nicht in Erinnerung bleiben.

Beispiel:

var regx =/user (?! name)/;

var rs = regx.exec ("Der Benutzername ist Mary");

Ergebnis: Die Übereinstimmung ist erfolgreich und der Wert von RS ist {Benutzer}

Beispiel 2:

var regx = // d+(?!/.)/;

var rs = regx.exec ("54,235");

Result: The matching result, the value of rs is {5}, and the mismatch is because 54 is followed by the "." Zeichen. Of course, 235 also matches, but due to the behavior of the exec method, 235 will not be returned.

12>x|y：匹配x或y。注意如果x和y都匹配上了，那么只记住x。

Beispiel:

var regx=/beijing|shanghai/;

var rs=regx.exec(“I love beijing and shanghai”);

结果：匹配成功，rs的值为{beijing}，虽然shanghai也匹配，但不会被记住。

13>{n}：匹配前一个字符的n次出现。

n必须是一个非负数，当然如果是一个负数或小数也不会报语法错误。

Beispiel:

var regx=/ab{2}c/;

var rs=regx.exec(“abbcd”);

结果：匹配成功，rs的值为：{abbc}。

14>{n,}：匹配前一个字符的至少n次出现。

Beispiel:

var regx=/ab{2,}c/;

var rs=regx.exec(“abbcdabbbc”);

结果：匹配成功，rs的值为：{abbc}。注意为什么abbbc也符合条件为什么没有被记住，这与exec方法的行为有关，后面会统一讲解。

15>{n,m}：匹配前一个字符的至少n次最多m次的出现。

只要n与m为数字，而且m>=n就不会报语法错误。

Beispiel:

var regx=/ab{2,5}c/;

var rs=regx.exec(“abbbcd”);

结果：匹配成功，rs的值为：{abbbc}。

Beispiel 2:

var regx=/ab{2,2}c/;

var rs=regx.exec(“abbcd”);

结果：匹配成功，rs的值为：{abbc}。

例子3：

var regx=/ab(2,5)/;

var rs=regx.exec(“abbbbbbbbbb”);

Result: The match is successful, and the value of rs is: {abbbbb}, which means that if the previous character appears more than m times, it will only match m times. Zusätzlich:

var regx=/ab(2,5)c/;

var rs=regx.exec(“abbbbbbbbbbc”);

结果：匹配失败，rs的值为：null，为什么匹配失败，因为b多于5个则b(2,5)会匹配前5个b，，而表达式/ab(2,5)c/中b后面是c，但字符串中5个b之后还是b所以会报错。

16>[xyz]：xyz表示一个字符串，该模式表示匹配[]中的一个字符，形式上[xyz]等同于[xz]。

Beispiel:

var regx=/a[bc]d/;

var rs=regx.exec(“abddgg”);

结果：匹配成功，rs的值为：{abd}

Beispiel 2:

var regx=/a[bc]d/;

var rs=regx.exec(“abcd”);

结果：匹配失败，rs的值为：null，之所以失败，是因为[bc]表示匹配b或c中的一个，但不会同时匹配。

17>[^xyz]：该模式表示匹配非[]中的一个字符，形式上[^xyz]等同于[^xz]。

Beispiel:

var regx=/a[^bc]d/;

var rs=regx.exec(“afddgg”);

结果：匹配成功，rs的值为：{afd}

Beispiel 2:

var regx=/a[^bc]d/;

var rs=regx.exec(“abd”);

结果：匹配失败，rs的值为：。

18>[/b]：匹配退格键。

19>/b：匹配一个词的边界符，例如空格和换行符等等，当然匹配换行符时，表达式应该附加参数m。

Beispiel:

var regx=//bc./;

var rs=regx.exec(“Beijing is a beautiful city”);

结果：匹配成功，rs的值为：{ci}，注意c前边的空格不会匹配到结果中，即{ ci}是不正确的。

20>/B：代表一个非单词边界。

Beispiel:

var regx=//Bi./;

var rs=regx.exec(“Beijing is a beautiful city”);

结果：匹配成功，rs的值为：{ij}，即匹配了Beijing中的ij。

21>/cX，匹配一个控制字符。例如， /cM 匹配一个Control-M 或

回车符。 x 的值必须为AZ 或az 之一。否则，将c 视为一

个原义的'c' 字符。（实际的例子还需补充）

21>/d：匹配一个数字字符，等同于[0-9]。

Beispiel:

var regx=/user/d/;

var rs=regx.exec(“user1”);

结果：匹配成功，rs的值为：{user1}

22>/D：匹配一个非数字字符，等同于[^0-9]。

Beispiel:

var regx=/user/D/;

var rs=regx.exec(“userA”);

结果：匹配成功，rs的值为：{userA}

23>/f：匹配一个换页符。

24>/n：匹配一个换行符。因为是换行符，所以在表达式中要加入m参数。

Beispiel:

var regx=/a/nbc/m;

var str=“a

bc”;

var rs=regx.exec(str);

结果：匹配成功，rs的值为：{ }，如果表达式为/a/n/rbc/，则不会被匹配，因此在一般的编辑器中一个”Enter”键代表着“回车换行”，而非“换行回车”，至少在textarea域中是这样的。

25>/r：匹配一个回车符

26>/s：匹配一个空格符，等同于[ /f/n/r/t/v/u00A0/u2028/u2029].

Beispiel:

var regx=//si/;

var rs=regx.exec(“Beijing is a city”);

结果：匹配成功，rs的值为：{ i}

27>/S：匹配一个非空格符，等同于[ ^/f/n/r/t/v/u00A0/u2028/u2029].

Beispiel:

var regx=//Si/;

var rs=regx.exec(“Beijing is a city”);

结果：匹配成功，rs的值为：{ei}

28>/t：匹配一个tab

Beispiel:

var regx=/a/tb/;

var rs=regx.exec(“a bc”);

结果：匹配成功，rs的值为： {a bc}

29>/v：匹配一个竖向的tab

30>/w：匹配一个数字、_或字母表字符，即[A-Za-z0-9_ ]。

Beispiel:

var regx=//w/;

var rs=regx.exec(“$25.23”);

结果：匹配成功，rs的值为：{2}

31>/W：匹配一个非数字、_或字母表字符，即[^A-Za-z0-9_ ]。

Beispiel:

var regx=//w/;

var rs=regx.exec(“$25.23”);

结果：匹配成功，rs的值为：{$}

32>/n：注意不是/n，这里n是一个正整数，表示匹配第n个()中的字符。

Beispiel:

var regx=/user([,-])group/1role/;

var rs=regx.exec(“user-group-role”);

结果：匹配成功，rs的值为：{user-group-role,-}，同样对user,group,role的匹配也是成功的，但像user-group,role等就不对了。

33>/0：匹配一个NUL字符。

34>/xhh：匹配一个由两位16进制数字所表达的字符。

35>/uhhhh：匹配一个由四位16进制数字所表达的字符。

3，表达式操作

1）表达式操作，在这里是指和表达式相关的方法，我们将介绍六个方法。

2）表达式对象（RegExp）方法：

1>exec(str)，返回str中与表达式相匹配的第一个字符串，而且以数组的形式表现，当然如果表达式中含有捕捉用的小括号，则返回的数组中也可能含有()中的匹配字符串，例如：

var regx=//d+/;

var rs=regx.exec(“3432ddf53”);

返回的rs值为：{3432}

var regx2=new RegExp(“ab(/d+)c”);

var rs2=regx2.exec(“ab234c44”);

返回的rs值为：{ab234c,234}

In addition, if there are multiple suitable matches, exec is executed for the first time and exec is continued, the second and third matches are returned in turn. Zum Beispiel:

var regx=/user/d/g;

var rs=regx.exec(“ddduser1dsfuser2dd”);

var rs1=regx.exec(“ddduser1dsfuser2dd”);

则rs的值为{user1}，rs的值为{rs2}，当然注意regx中的g参数是必须的，否则无论exec执行多少次，都返回第一个匹配。后面还有相关内容涉及到对此想象的解释。

2>test(str), determines whether the string str matches the expression, and returns a boolean value. Zum Beispiel:

var regx=/user/d+/g;

var flag=regx.test(“user12dd”);

flag的值为true。

3）String对象方法

1>match(expr)，返回与expr相匹配的一个字符串数组，如果没有加参数g，则返回第一个匹配，加入参数g则返回所有的匹配

Beispiel:

var regx=/user/d/g;

var str=“user13userddduser345”;

var rs=str.match(regx);

rs的值为：{user1,user3}

2>search(expr)，返回字符串中与expr相匹配的第一个匹配的index值。

Beispiel:

var regx=/user/d/g;

var str=“user13userddduser345”;

var rs=str.search(regx);

rs的值为：0

3>replace(expr,str)，将字符串中匹配expr的部分替换为str。另外在replace方法中，str中可以含有一种变量符号$，格式为$n，代表匹配中被记住的第n的匹配字符串（注意小括号可以记忆匹配）。

Beispiel:

var regx=/user/d/g;

var str=“user13userddduser345”;

var rs=str.replace(regx,”00”);

rs的值为：003userddd0045

Beispiel 2:

var regx=/u(se)r/d/g;

var str=“user13userddduser345”;

var rs=str.replace(regx,”$1”);

rs的值为：se3userdddse45

对于replace(expr,str)方法还要特别注意一点，如果expr是一个表达式对象则会进行全局替换（此时表达式必须附加参数g，否则也只是替换第一个匹配），如果expr是一个字符串对象，则只会替换第一个匹配的部分，例如：

var regx=“user”

var str=“user13userddduser345”;

var rs=str.replace(regx,”00”);

rs的值为： 0013userddduser345

4>split(expr)，将字符串以匹配expr的部分做分割，返回一个数组，而且表达式是否附加参数g都没有关系，结果是一样的。

Beispiel:

var regx=/user/d/g;

var str=“user13userddduser345”;

var rs=str.split(regx);

rs的值为：{3userddd,45}

4，表达式相关属性

1）表达式相关属性，是指和表达式相关的属性，如下面的形式：

var regx=/myexpr/;

var rs=regx.exec(str);

其中，和表达式自身regx相关的属性有两个，和表达式匹配结果rs相关的属性有三个，下面将逐一介绍。

2）和表达式自身相关的两个属性：

1>lastIndex，返回开始下一个匹配的位置，注意必须是全局匹配（表达式中带有g参数）时，lastIndex才会有不断返回下一个匹配值，否则该值为总是返回第一个下一个匹配位置，例如：

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var lastIndex1=regx.lastIndex;

rs=regx.exec(“sdsfuser1dfsfuser2”);

var lastIndex2=regx.lastIndex;

rs=regx.exec(“sdsfuser1dfsfuser2”);

var lastIndex3=regx.lastIndex;

上面lastIndex1为9，第二个lastIndex2也为9，第三个也是9；如果regx=/user/d/g，则第一个为9，第二个为18，第三个为0。

2>source, return the expression string itself. Zum Beispiel:

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var source=regx.source;

source的值为user/d

3）和匹配结果相关的三个属性：

1>index, return the current matching position. Zum Beispiel:

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var index1=rs.index;

rs=regx.exec(“sdsfuser1dfsfuser2”);

var index2=rs.index;

rs=regx.exec(“sdsfuser1dfsfuser2”);

var index3=rs.index;

index1为4，index2为4，index3为4，如果表达式加入参数g，则index1为4，index2为13，index3会报错（index为空或不是对象）。

2>input, used for matching strings. Zum Beispiel:

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var input=rs.input;

input的值为sdsfuser1dfsfuser2。

3>[0]，返回匹配结果中的第一个匹配值，对于match而言可能返回一个多值的数字，则除了[0]外，还可以取[1]、[2]等等。例如：

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var value1=rs[0];

rs=regx.exec(“sdsfuser1dfsfuser2”);

var value2=rs[0];

value1的值为user1,value2的值为user2

5，实际应用

1）实际应用一

描述：有一表单，其中有一个“用户名”input域

要求：汉字，而且不能少于2个汉字，不能多于4个汉字。

erreichen:

 <script>function checkForm(obj){ var username=obj.username.value; var regx=/^[/u4e00-/u9fa5]{2,4}$/g if(!regx.test(username)){ alert(“Invalid username!”); return false; } return true;}</script><form name=“myForm”onSubmit=“return checkForm(this)”> <input type=“text” name=“username”/> <input type=“submit” vlaue=“submit”/></form>

2）实际应用二

描述：给定一个含有html标记的字符串，要求将其中的html标记去掉。

erreichen:

 <script>function toPlainText(htmlStr){ var regx=/<[^>]*>|<//[^>]*>/gm; var str=htmlStr.replace(regx,""); return str;}</script><form name=“myForm”> <textarea id=“htmlInput”></textarea> <input type=“button” value=“submit” onclick=“toPlainText(document.getElementById('htmlInput').value”/></form>

三，小结

1，Javascript正则表达式，我想在一般的程序员之中，使用者应该不是很多，因为我们处理的页面一般都不是很复杂，而复杂的逻辑一般我们都在后台处理完成了。但是目前趋势已经出现了扭转，富客户端已经被越来越多的人接受，而Javascript就是其中的关键技术，对于复杂的客户端逻辑而言，正则表达式的作用也是很关键的，同时它也是Javascript高手必须要掌握的重要技术之一。

2，为了能够便于大家对前面讲述的内容有一个更为综合和深刻的认识，我将前面的一些关键点和容易犯糊涂的地方再系统总结一下，这部分很关键！

总结1：附件参数g的用法

表达式加上参数g之后，表明可以进行全局匹配，注意这里“可以”的含义。我们详细叙述：

1) For the exec method of the expression object, if g is not added, it will only return the first match, no matter how many times it is executed, if g is added, the first execution will also return the first match, and then the execution will return the second match, and so on. Zum Beispiel

var regx=/user/d/;

var str=“user18dsdfuser2dsfsd”;

var rs=regx.exec(str);//此时rs的值为{user1}

var rs2=regx.exec(str);//此时rs的值依然为{user1}

如果regx=/user/d/g；则rs的值为{user1}，rs2的值为{user2}

通过这个例子说明：对于exec方法，表达式加入了g，并不是说执行exec方法就可以返回所有的匹配，而是说加入了g之后，我可以通过某种方式得到所有的匹配，这里的“方式”对于exec而言，就是依次执行这个方法即可。

2）对于表达式对象的test方法，加入g于不加上g没有什么区别。

3) For the match method of the String object, g is not added, and it only returns the first match. If the match method is executed all the time, it always returns the first match. If g is added, then all matches will be returned at once (note that this is different from the exec method of the expression object. For exec, even if g is added, all matches will not be returned at once). Zum Beispiel:

var regx=/user/d/;

var str=“user1sdfsffuser2dfsdf”;

var rs=str.match(regx);//此时rs的值为{user1}

var rs2=str.match(regx);//此时rs的值依然为{user1}

如果regx=/user/d/g，则rs的值为{user1,user2}，rs2的值也为{user1,user2}

4）对于String对象的replace方法，表达式不加入g，则只替换第一个匹配，如果加入g，则替换所有匹配。（开头的三道测试题能很好的说明这一点）

5）对于String对象的split方法，加上g与不加g是一样的，即：

var sep=/user/d/;

var array=“user1dfsfuser2dfsf”.split(sep);

则array的值为{dfsf, dfsf}

此时sep=/user/d/g，返回值是一样的。

6）对于String对象的search方法，加不加g也是一样的。

总结2：附加参数m的用法

附加参数m，表明可以进行多行匹配，但是这个只有当使用^和$模式时才会起作用，在其他的模式中，加不加入m都可以进行多行匹配（其实说多行的字符串也是一个普通字符串），我们举例说明这一点

1）使用^的例子

var regx=/^b./g;var str=“bd76 dfsdf sdfsdfs dffs b76dsf sdfsdf”;var rs=str.match(regx);

此时加入g和不加入g，都只返回第一个匹配{bd}，如果regx=/^b./gm，则返回所有的匹配{bd,b7}，注意如果regx=/^b./m，则也只返回第一个匹配。所以，加入m表明可以进行多行匹配，加入g表明可以进行全局匹配，综合到一起就是可以进行多行全局匹配

2）使用其他模式的例子，例如

var regx=/user/d/;var str=“sdfsfsdfsdf sdfsuser3 dffs b76dsf user6”;var rs=str.match(regx);

此时不加参数g，则返回{user3}，加入参数g返回{user3,user6}，加不加入m对此没有影响。

3）因此对于m我们要清楚它的使用，记住它只对^和$模式起作用，在这两种模式中，m的作用为：如果不加入m，则只能在第一行进行匹配，如果加入m则可以在所有的行进行匹配。我们再看一个^的例子

var regx=/^b./;var str=“ret76 dfsdf bjfsdfs dffs b76dsf sdfsdf”;var rs=str.match(regx);

此时rs的值为null，如果加入g，rs的值仍然为null，如果加入m，则rs的值为{bj}（也就是说，在第一行没有找到匹配，因为有参数m，所以可以继续去下面的行去找是否有匹配），如果m和g都加上，则返回{bj,b7}（只加m不加g说明，可以去多行进行匹配，但是找到一个匹配后就返回，加入g表明将多行中所有的匹配返回，当然对于match方法是如此，对于exec呢，则需要执行多次才能依次返回）

总结3：

在HTML的textarea输入域中，按一个Enter键，对应的控制字符为“/r/n”，即“回车换行”，而不是“/n/r”，即“换行回车”，我们看一个前面我们举过的例子：

 var regx=/a/r/nbc/;var str=“a bc”;var rs=regx.exec(str);

结果：匹配成功，rs的值为：{ }，如果表达式为/a/n/rbc/，则不会被匹配，因此在一般的编辑器中一个”Enter”键代表着“回车换行”，而非“换行回车”，至少在textarea域中是这样的。

The above article briefly discusses the use of RegExp objects and brackets for JS regular expressions is all the content I share with you. Ich hoffe, es kann Ihnen eine Referenz geben und ich hoffe, Sie können Wulin.com mehr unterstützen.