Reguläre Javascript-Ausdrücke.

Methode replace() durch regulären Ausdruck Letzte Aktualisierung: 01.11.2015 Reguläre Ausdrücke.

stellen ein Muster dar, das zum Suchen oder Ändern einer Zeichenfolge verwendet wird. Um mit regulären Ausdrücken in JavaScript zu arbeiten, wird ein Objekt definiert

RegExp

Es gibt zwei Möglichkeiten, einen regulären Ausdruck zu definieren:

Var myExp = /hello/; var myExp = new RegExp("hello");

Der hier verwendete reguläre Ausdruck ist recht einfach: Er besteht aus einem einzigen Wort, „Hallo“. Im ersten Fall wird der Ausdruck zwischen zwei Schrägstrichen platziert und im zweiten Fall wird der RegExp-Konstruktor verwendet, an den der Ausdruck als String übergeben wird.

RegExp-Methoden
Um festzustellen, ob ein regulärer Ausdruck mit einer Zeichenfolge übereinstimmt, definiert das RegExp-Objekt eine test()-Methode. Diese Methode gibt true zurück, wenn die Zeichenfolge mit dem regulären Ausdruck übereinstimmt, und false, wenn dies nicht der Fall ist.

Var initialText = "Hallo Welt!"; var exp = /hallo/; var result = exp.test(initialText); document.write(result + "

"); // true initialText = "beautifull Weather"; result = exp.test(initialText); document.write(result); // false - es gibt kein „hello“ in der initialText-Zeile
Die exec-Methode funktioniert auf ähnliche Weise – sie prüft auch, ob die Zeichenfolge mit dem regulären Ausdruck übereinstimmt, nur dass diese Methode jetzt den Teil der Zeichenfolge zurückgibt, der mit dem Ausdruck übereinstimmt. Wenn es keine Übereinstimmungen gibt, wird null zurückgegeben.

Var initialText = "Hallo Welt!"; var exp = /hallo/; var result = exp.exec(initialText); document.write(result + "

"); // hallo initialText = "schönes Wetter"; result = exp.exec(initialText); document.write(result); // null

Var initialText = "defensiveness"; var exp = /[abc]/; var result = exp.test(initialText); document.write(result + "
"); // true initialText = "city"; result = exp.test(initialText); document.write(result); // false

Der Ausdruck [abc] gibt an, dass die Zeichenfolge einen von drei Buchstaben haben muss.

Wenn wir das Vorhandensein alphabetischer Zeichen aus einem bestimmten Bereich in einer Zeichenfolge ermitteln müssen, können wir diesen Bereich einmal angeben:

Var initialText = "defensiveness"; var exp = /[a-z]/; var result = exp.test(initialText); document.write(result + "
"); // true initialText = "3di0789"; result = exp.test(initialText); document.write(result); // false

In diesem Fall muss die Zeichenfolge mindestens ein Zeichen aus dem Bereich a-z enthalten.

Wenn Sie hingegen nicht möchten, dass die Zeile nur bestimmte Zeichen enthält, müssen Sie vor der Auflistung der Zeichen ein ^-Zeichen in eckigen Klammern einfügen:

Var initialText = "defensiveness"; var exp = /[^a-z]/; var result = exp.test(initialText); document.write(result + "
"); // false initialText = "3di0789"; exp = /[^0-9]/; result = exp.test(initialText); document.write(result); // true

Im ersten Fall sollte die Zeichenfolge nicht nur Zeichen aus dem Bereich a-z enthalten, aber da die Zeichenfolge „defensiveness“ nur aus Zeichen aus diesem Bereich besteht, gibt die Methode test() false zurück, d. h. der reguläre Ausdruck stimmt nicht mit überein Abfluss.

Im zweiten Fall („3di0789“) darf die Zeichenfolge nicht nur aus numerischen Zeichen bestehen. Da der String aber auch Buchstaben enthält, stimmt der String mit dem regulären Ausdruck überein, sodass die Testmethode „true“ zurückgibt.

Bei Bedarf können wir Ausdruckskombinationen sammeln:

Var initialText = "home"; var exp = /[dt]o[nm]/; var result = exp.test(initialText); document.write(result); // WAHR

Der Ausdruck [dt]o[nm] gibt die Zeilen an, die die Teilzeichenfolgen „house“, „volume“, „don“, „tone“ enthalten können.

Ausdruckseigenschaften

Mit der globalen Eigenschaft können Sie alle Teilzeichenfolgen finden, die einem regulären Ausdruck entsprechen. Standardmäßig wählt der reguläre Ausdruck bei der Suche nach Teilzeichenfolgen die erste Teilzeichenfolge aus der Zeichenfolge aus, die dem Ausdruck entspricht. Allerdings kann es in einer Zeichenfolge viele Teilzeichenfolgen geben, die auch mit dem Ausdruck übereinstimmen. Verwenden Sie dazu diese Eigenschaft in Form des Symbols g in Ausdrücken

Mit der Eigenschaft „ignoreCase“ können Sie Teilzeichenfolgen finden, die einem regulären Ausdruck entsprechen, unabhängig von der Groß-/Kleinschreibung der Zeichen in der Zeichenfolge. Dazu wird in regulären Ausdrücken das Zeichen i verwendet

Mit der Eigenschaft „mehrzeilig“ können Sie Teilzeichenfolgen finden, die einem regulären Ausdruck in mehrzeiligem Text entsprechen. Dazu wird in regulären Ausdrücken das Symbol m verwendet

Zum Beispiel:

Var initialText = "Hallo Welt"; var exp = /world/; var result = exp.test(initialText); // FALSCH

Hier gibt es keine Übereinstimmung zwischen der Zeichenfolge und dem Ausdruck, da sich „World“ von „world“ in der Groß-/Kleinschreibung unterscheidet. In diesem Fall müssen Sie den regulären Ausdruck ändern, indem Sie ihm die Eigenschaft „ignoreCase“ hinzufügen:

Var exp = /world/i;

Nun, wir können auch mehrere Eigenschaften gleichzeitig verwenden.

Die RegExp-Klasse in JavaScript ist ein regulärer Ausdruck – ein Objekt, das ein Zeichenmuster beschreibt. RegExp-Objekte werden normalerweise mit der unten dargestellten speziellen Literalsyntax erstellt, können aber auch mit dem RegExp()-Konstruktor erstellt werden.

Syntax

Parameterwerte:

Flags für reguläre Ausdrücke

Zeichensätze

Metazeichen

Einschränkungen

Quantifizierer

Gruppierung und Backlinks

Manche Leute denken, wenn sie mit einem Problem konfrontiert werden: „Oh, ich werde reguläre Ausdrücke verwenden.“ Jetzt haben sie zwei Probleme.
Jamie Zawinski

Yuan-Ma sagte: „Es erfordert viel Kraft, Holz quer zur Holzmaserung zu schneiden. Es erfordert viel Code, um die Problemstruktur zu programmieren.
Meister Yuan-Ma, „Buch der Programmierung“

Programmierwerkzeuge und -techniken überleben und verbreiten sich auf chaotische, evolutionäre Weise. Manchmal überleben nicht die Schönen und Genialen, sondern einfach diejenigen, die in ihrem Fachgebiet gut genug funktionieren – zum Beispiel, wenn sie in eine andere erfolgreiche Technologie integriert werden.

In diesem Kapitel werden wir ein solches Tool besprechen – reguläre Ausdrücke. Dies ist eine Möglichkeit, Muster in Zeichenfolgendaten zu beschreiben. Sie erstellen eine kleine, eigenständige Sprache, die in JavaScript und vielen anderen Sprachen und Tools enthalten ist.

Die regulären Zeitpläne sind sowohl sehr seltsam als auch äußerst nützlich. Ihre Syntax ist kryptisch und ihre JavaScript-Programmierschnittstelle ist klobig. Aber es ist ein leistungsstarkes Werkzeug zum Erkunden und Bearbeiten von Zeichenfolgen. Sobald Sie sie verstanden haben, werden Sie ein effektiverer Programmierer.

Einen regulären Ausdruck erstellen

Var re1 = new RegExp("abc"); var re2 = /abc/;

Beide regulären Ausdrücke stellen dasselbe Muster dar: das Zeichen „a“, gefolgt vom Zeichen „b“, gefolgt vom Zeichen „c“.

Wenn Sie den RegExp-Konstruktor verwenden, wird das Muster als reguläre Zeichenfolge geschrieben, sodass alle Regeln für Backslashes gelten.

Der zweite Eintrag, bei dem das Muster zwischen Schrägstrichen liegt, behandelt Backslashes unterschiedlich. Da das Muster mit einem Schrägstrich endet, müssen wir zunächst einen Backslash vor dem Schrägstrich einfügen, den wir in unser Muster aufnehmen möchten. Darüber hinaus bleiben Backslashes, die nicht Teil von Sonderzeichen wie \n sind, erhalten (und werden nicht wie in Zeichenfolgen ignoriert) und ändern die Bedeutung des Musters. Einige Zeichen wie das Fragezeichen oder das Pluszeichen haben in regulären Ausdrücken eine besondere Bedeutung. Wenn Sie ein solches Zeichen finden müssen, muss ihm auch ein Backslash vorangestellt werden.

Var EighteenPlus = /Eighteen\+/;

Um zu wissen, welchen Zeichen ein Schrägstrich vorangestellt werden muss, müssen Sie eine Liste aller Sonderzeichen in regulären Ausdrücken lernen. Dies ist noch nicht möglich. Setzen Sie daher im Zweifelsfall einfach einen Backslash vor jedes Zeichen, das kein Buchstabe, keine Zahl oder ein Leerzeichen ist.

Auf Übereinstimmungen prüfen

Console.log(/abc/.test("abcde")); // → true console.log(/abc/.test("abxde")); // → falsch

Eine reguläre Folge, die nur aus Nicht-Sonderzeichen besteht, ist einfach eine Folge dieser Zeichen. Wenn sich abc an einer beliebigen Stelle in der Zeile befindet, die wir testen (nicht nur am Anfang), gibt test „true“ zurück.

Auf der Suche nach einer Reihe von Charakteren

Nehmen wir an, wir müssen eine beliebige Zahl finden. Wenn wir in einem regulären Ausdruck eine Reihe von Zeichen in eckige Klammern setzen, bedeutet dies, dass dieser Teil des Ausdrucks mit einem der Zeichen in den Klammern übereinstimmt.

Beide Ausdrücke stehen in Zeilen, die eine Zahl enthalten.

Console.log(//.test("in 1992")); // → true console.log(//.test("in 1992")); // → wahr

In eckigen Klammern wird ein Bindestrich zwischen zwei Zeichen verwendet, um einen Zeichenbereich anzugeben, wobei die Reihenfolge durch die Unicode-Kodierung angegeben wird. Die Zeichen von 0 bis 9 sind nur in einer Reihe vorhanden (Codes von 48 bis 57), daher werden sie alle erfasst und mit jeder Zahl abgeglichen.

Mehrere Zeichengruppen verfügen über eigene integrierte Abkürzungen.

\d Beliebige Zahl
\w Alphanumerisches Zeichen
\s Leerzeichen (Leerzeichen, Tabulator, Zeilenumbruch usw.)
\D keine Zahl
\W ist kein alphanumerisches Zeichen
\S ist kein Leerzeichen
. beliebiges Zeichen außer Zeilenvorschub

So können Sie das Datums- und Uhrzeitformat wie 30.01.2003 15:20 mit dem folgenden Ausdruck festlegen:

Var dateTime = /\d\d-\d\d-\d\d\d\d \d\d:\d\d/; console.log(dateTime.test("30-01-2003 15:20")); // → true console.log(dateTime.test("30-Jan-2003 15:20")); // → falsch

Sieht schrecklich aus, nicht wahr? Es gibt zu viele Backslashes, wodurch das Muster schwer zu verstehen ist. Wir werden es später etwas verbessern.

Backslashes können auch in eckigen Klammern verwendet werden. Beispielsweise bedeutet [\d.] eine beliebige Zahl oder einen beliebigen Punkt. Beachten Sie, dass der Punkt in den eckigen Klammern seine besondere Bedeutung verliert und einfach zu einem Punkt wird. Dasselbe gilt auch für andere Sonderzeichen, wie zum Beispiel +.

Sie können einen Satz von Zeichen umkehren – das heißt, Sie müssen alle Zeichen außer denen finden, die im Satz enthalten sind –, indem Sie direkt nach der öffnenden eckigen Klammer ein ^-Zeichen setzen.

Var notBinary = /[^01]/; console.log(notBinary.test("1100100010100110")); // → false console.log(notBinary.test("1100100010200110")); // → wahr

Wiederholte Teile der Vorlage

Wenn Sie in der regulären Reihenfolge hinter etwas ein +-Zeichen setzen, bedeutet dies, dass dieses Element mehr als einmal wiederholt werden kann. /\d+/ bedeutet eine oder mehrere Ziffern.

Console.log(/"\d+"/.test(""123"")); // → true console.log(/"\d+"/.test("""")); // → false console.log(/"\d*"/.test(""123"")); // → true console.log(/"\d*"/.test("""")); // → wahr

Das Sternchen * hat fast die gleiche Bedeutung, lässt jedoch zu, dass das Muster null Mal auftritt. Wenn auf etwas ein Sternchen folgt, verhindert das nie, dass das Muster in der Zeile steht – es erscheint dort einfach null Mal.

Ein Fragezeichen macht einen Teil des Musters optional, d. h. er kann null oder einmal vorkommen. Im folgenden Beispiel erscheint möglicherweise das Zeichen u, aber das Muster stimmt auch dann überein, wenn dies nicht der Fall ist.

Var benachbart = /neighbour?r/; console.log(neighbor.test("neighbor")); // → true console.log(neighbor.test("neighbor")); // → wahr

Mit geschweiften Klammern wird angegeben, wie oft ein Muster genau vorkommen muss. (4) nach einem Element bedeutet, dass es viermal in der Zeile vorkommen muss. Sie können auch eine Lücke angeben: (2,4) bedeutet, dass das Element mindestens 2 und höchstens 4 Mal vorkommen muss.

Eine andere Version des Datums- und Uhrzeitformats, bei der Tage, Monate und Stunden mit einer oder zwei Ziffern zulässig sind. Und es ist auch etwas besser lesbar.

Var dateTime = /\d(1,2)-\d(1,2)-\d(4) \d(1,2):\d(2)/; console.log(dateTime.test("30-1-2003 8:45")); // → wahr

Sie können offene Leerzeichen verwenden, indem Sie eine der Zahlen weglassen. (,5,) bedeutet, dass das Muster null bis fünfmal auftreten kann, und (5,) bedeutet fünfmal oder öfter.

Unterausdrücke gruppieren

Var cartoonCrying = /boo+(hoo+)+/i; console.log(cartoonCrying.test("Boohoooohoohooo")); // → wahr

Das erste und das zweite Pluszeichen gelten nur für das zweite O in Buh und Hoo. Das dritte + bezieht sich auf die gesamte Gruppe (hoo+), die eine oder mehrere solcher Sequenzen findet.

Durch den Buchstaben i am Ende des Ausdrucks wird die Groß-/Kleinschreibung des regulären Ausdrucks nicht beachtet, sodass B mit b übereinstimmt.

Spiele und Gruppen

Var match = /\d+/.exec("one two 100"); console.log(match); // → ["100"] console.log(match.index); // → 8

Das von exec zurückgegebene Objekt verfügt über eine Indexeigenschaft, die die Nummer des Zeichens enthält, von dem aus die Übereinstimmung aufgetreten ist. Im Allgemeinen sieht das Objekt wie ein Array aus Zeichenfolgen aus, wobei das erste Element die Zeichenfolge ist, die auf Übereinstimmung überprüft wurde. In unserem Beispiel ist dies die gesuchte Zahlenfolge.

Strings verfügen über eine Match-Methode, die auf die gleiche Weise funktioniert.

Console.log("eins zwei 100".match(/\d+/)); // → ["100"]

Wenn ein regulärer Ausdruck durch Klammern gruppierte Unterausdrücke enthält, wird der Text, der diesen Gruppen entspricht, auch im Array angezeigt. Das erste Element ist immer eine vollständige Übereinstimmung. Der zweite ist der Teil, der mit der ersten Gruppe übereinstimmte (derjenige, dessen Klammern zuerst auftraten), dann mit der zweiten Gruppe und so weiter.

Var quotedText = /"([^"]*)"/; console.log(quotedText.exec("sie sagte "hello"")); // → [""hello"", "hello"]

Wenn eine Gruppe überhaupt nicht gefunden wird (z. B. wenn auf sie ein Fragezeichen folgt), ist ihre Position im Array undefiniert. Wenn eine Gruppe mehrmals übereinstimmt, befindet sich nur die letzte Übereinstimmung im Array.

Console.log(/bad(ly)?/.exec("bad")); // → ["bad", undefiniert] console.log(/(\d)+/.exec("123")); // → ["123", "3"]

Gruppen sind nützlich, um Teile von Zeichenfolgen abzurufen. Wenn wir nicht nur prüfen möchten, ob ein String ein Datum hat, sondern ihn extrahieren und ein Objekt erstellen möchten, das das Datum darstellt, können wir die Zahlenfolgen in Klammern setzen und das Datum aus dem Ergebnis von exec auswählen.

Aber zuerst ein kleiner Exkurs, in dem wir lernen, wie Datum und Uhrzeit am besten in JavaScript gespeichert werden.

Datumstyp

Console.log(new Date()); // → So 9. Nov. 2014 00:07:57 GMT+0300 (MEZ)

Sie können auch ein Objekt erstellen, das eine bestimmte Zeit enthält

Console.log(neues Datum(2015, 9, 21)); // → Mi 21. Okt. 2015 00:00:00 GMT+0300 (MEZ) console.log(new Date(2009, 11, 9, 12, 59, 59, 999)); // → Mi 9. Dez. 2009 12:59:59 GMT+0300 (MEZ)

JavaScript verwendet eine Konvention, bei der Monatszahlen mit einer Null und Tageszahlen mit einer Eins beginnen. Das ist dumm und lächerlich. Seien Sie vorsichtig.

Die letzten vier Argumente (Stunden, Minuten, Sekunden und Millisekunden) sind optional und werden auf Null gesetzt, wenn sie fehlen.

Zeitstempel werden als Anzahl der Millisekunden gespeichert, die seit Anfang 1970 vergangen sind. Für Zeiten vor 1970 werden negative Zahlen verwendet (dies liegt an der Unix-Zeitkonvention, die zu dieser Zeit erstellt wurde). Die getTime-Methode des Datumsobjekts gibt diese Zahl zurück. Es ist von Natur aus groß.
console.log(new Date(2013, 11, 19).getTime()); // → 1387407600000 console.log(new Date(1387407600000)); // → Do 19. Dezember 2013 00:00:00 GMT+0100 (MEZ)

Wenn Sie dem Date-Konstruktor ein Argument geben, wird es als diese Anzahl von Millisekunden behandelt. Sie können den aktuellen Millisekundenwert abrufen, indem Sie ein Date-Objekt erstellen und die Methode getTime aufrufen oder indem Sie die Funktion Date.now aufrufen.

Das Date-Objekt verfügt über die Methoden getFullYear, getMonth, getDate, getHours, getMinutes und getSeconds, um seine Komponenten abzurufen. Es gibt auch eine getYear-Methode, die einen eher nutzlosen zweistelligen Code wie 93 oder 14 zurückgibt.

Indem wir die relevanten Teile der Vorlage in Klammern setzen, können wir direkt aus der Zeichenfolge ein Datumsobjekt erstellen.

Funktion findDate(string) ( var dateTime = /(\d(1,2))-(\d(1,2))-(\d(4))/; var match = dateTime.exec(string); return new Date(Number(match), Number(match) - 1, Number(match) ) console.log(findDate("30-1-2003")); // → Do 30. Januar 2003 00:00:00 GMT+0100 (MEZ)

Wort- und Zeilengrenzen

Wenn wir die Übereinstimmung erzwingen müssen, um die gesamte Zeichenfolge zu übernehmen, verwenden wir die Tags ^ und $. ^ entspricht dem Anfang der Zeile und $ entspricht dem Ende. Daher entspricht /^\d+$/ einer Zeichenfolge, die nur eine oder mehrere Ziffern enthält, /^!/ entspricht einer Zeichenfolge, die mit einem Ausrufezeichen beginnt, und /x^/ entspricht keiner Zeichenfolge (es darf kein x geben).

Wenn wir hingegen nur sicherstellen möchten, dass das Datum an einer Wortgrenze beginnt und endet, verwenden wir die Markierung \b. Eine Wortgrenze kann der Anfang oder das Ende einer Zeile sein oder jede Stelle in einer Zeile, an der sich auf der einen Seite ein alphanumerisches Zeichen \w und auf der anderen Seite ein nicht-alphanumerisches Zeichen befindet.

Console.log(/cat/.test("concatenate")); // → true console.log(/\bcat\b/.test("concatenate")); // → falsch

Beachten Sie, dass die Grenzbeschriftung kein Symbol ist. Es handelt sich lediglich um eine Einschränkung, die bedeutet, dass eine Übereinstimmung nur dann erfolgt, wenn eine bestimmte Bedingung erfüllt ist.

Vorlagen mit Auswahl

Es wäre möglich, drei reguläre Ausdrücke zu schreiben und sie einzeln zu überprüfen, aber es gibt einen besseren Weg. Symbol | bezeichnet eine Auswahl zwischen den Mustern links und rechts davon. Und wir können Folgendes sagen:

Var animalCount = /\b\d+ (Schwein|Kuh|Hühner)s?\b/; console.log(animalCount.test("15 Schweine")); // → true console.log(animalCount.test("15 pigchickens")); // → falsch

Klammern begrenzen den Teil des Musters, auf den | angewendet wird, und viele solcher Operatoren können nacheinander platziert werden, um eine Auswahl aus mehr als zwei Optionen anzuzeigen.

Suchmaschine

Ein Ausdruck stimmt mit einer Zeichenfolge überein, wenn es möglich ist, einen Pfad von der linken Seite des Diagramms nach rechts zu finden. Wir merken uns die aktuelle Position in der Zeile und jedes Mal, wenn wir durch das Rechteck gehen, überprüfen wir, ob der Teil der Zeile direkt hinter unserer Position darin mit dem Inhalt des Rechtecks ​​übereinstimmt.

Das bedeutet, dass die Überprüfung, ob unser reguläres Zeichen mit der Zeichenfolge „die 3 Schweine“ übereinstimmt, beim Durchgehen des Flussdiagramms wie folgt aussieht:

An Position 4 gibt es eine Wortgrenze und wir passieren das erste Rechteck
- Ab der 4. Position suchen wir die Zahl und gehen durch das zweite Rechteck
- An Position 5 schließt sich ein Pfad wieder vor dem zweiten Rechteck und der zweite geht mit einem Leerzeichen weiter zum Rechteck. Wir haben ein Leerzeichen, keine Zahl, und wählen den zweiten Pfad.
- Jetzt sind wir bei Position 6, dem Anfang von „Schweine“, und bei der dreifachen Verzweigung der Wege. In der Reihe steht weder „Kuh“ noch „Huhn“, dafür aber „Schwein“, also wählen wir diesen Weg.
- An Position 9 nach der Dreifachgabelung umgeht ein Pfad „s“ und geht zum letzten Wortbegrenzungsrechteck, und der zweite geht durch „s“. Wir haben ein „s“, also gehen wir dorthin.
- Bei Position 10 sind wir am Ende der Zeile und nur die Wortgrenze kann übereinstimmen. Das Ende der Linie gilt als Grenze und wir gehen durch das letzte Rechteck. Und nun haben wir unsere Vorlage erfolgreich gefunden.

Grundsätzlich funktionieren reguläre Ausdrücke so, dass der Algorithmus am Anfang der Zeichenfolge beginnt und versucht, dort eine Übereinstimmung zu finden. In unserem Fall gibt es eine Wortgrenze, also passiert es das erste Rechteck – aber dort gibt es keine Zahl, also stolpert es über das zweite Rechteck. Dann geht es zum zweiten Zeichen in der Zeichenfolge und versucht, dort eine Übereinstimmung zu finden ... Und so weiter, bis eine Übereinstimmung gefunden wird oder das Ende der Zeichenfolge erreicht wird. In diesem Fall wird keine Übereinstimmung gefunden.

Rückschläge

Bei der Suche nach einer Übereinstimmung kann es vorkommen, dass der Algorithmus den obersten Pfad (Binärzahl) wählt, auch wenn in der Zeichenfolge keine solche Zahl vorhanden ist. Wenn es beispielsweise eine Zeile „103“ gibt, ist klar, dass der Algorithmus erst nach Erreichen der Zahl 3 erkennt, dass er auf dem falschen Weg ist. Im Allgemeinen stimmt die Zeile mit der regulären Reihenfolge überein, nur nicht in diesem Thread.

Dann wird der Algorithmus zurückgesetzt. An einer Gabelung merkt es sich die aktuelle Position (in unserem Fall ist dies der Anfang der Zeile, direkt nach der Wortgrenze), sodass Sie zurückgehen und einen anderen Weg ausprobieren können, wenn der gewählte Weg nicht funktioniert. Bei der Zeichenfolge „103“ wird nach dem Auftreffen auf eine Drei zurückgegangen und versucht, den Dezimalpfad zu durchlaufen. Dies wird funktionieren, sodass eine Übereinstimmung gefunden wird.

Der Algorithmus stoppt, sobald er eine vollständige Übereinstimmung findet. Dies bedeutet, dass auch wenn mehrere Optionen geeignet sind, nur eine davon verwendet wird (in der Reihenfolge, in der sie in der regulären Reihenfolge erscheinen).

Backtracking tritt auf, wenn Wiederholungsoperatoren wie + und * verwendet werden. Wenn Sie in der Zeichenfolge „abcxe“ nach /^.*x/ suchen, versucht der Regex-Teil.*, die gesamte Zeichenfolge zu verbrauchen. Der Algorithmus wird dann erkennen, dass er auch „x“ benötigt. Da nach dem Ende der Zeichenfolge kein „x“ steht, versucht der Algorithmus, nach einer Übereinstimmung zu suchen, indem er ein Zeichen nach hinten verschiebt. Nach abcx gibt es auch kein x, dann wird wieder zurückgerollt, diesmal auf den Teilstring abc. Und nach der Zeile findet es x und meldet eine erfolgreiche Übereinstimmung an den Positionen 0 bis 4.

Sie können eine reguläre Routine schreiben, die zu mehreren Rollbacks führt. Dieses Problem tritt auf, wenn das Muster auf viele verschiedene Arten mit der Eingabe übereinstimmen kann. Wenn wir beispielsweise beim Schreiben des regulären Ausdrucks für Binärzahlen einen Fehler machen, schreiben wir möglicherweise versehentlich etwas wie /(+)+b/.

Wenn der Algorithmus nach einem solchen Muster in einer langen Folge von Nullen und Einsen suchen würde, die am Ende kein „b“ hätten, würde er zunächst die innere Schleife durchlaufen, bis ihm die Ziffern ausgehen. Dann wird er bemerken, dass am Ende kein „b“ steht, er wird eine Position zurückrollen, durch die äußere Schleife gehen, wieder aufgeben, versuchen, entlang der inneren Schleife zu einer anderen Position zurückzurollen ... Und er wird weitermachen um auf diese Weise zu suchen und dabei beide Schleifen zu verwenden. Das heißt, der Arbeitsaufwand mit jedem Zeichen der Zeile verdoppelt sich. Selbst bei mehreren Dutzend Charakteren wird es sehr lange dauern, eine Übereinstimmung zu finden.

Ersetzungsmethode

Console.log("dad".replace("p", "m")); // → Karte

Das erste Argument kann auch ein regulärer Ausdruck sein. In diesem Fall wird das erste Vorkommen des regulären Ausdrucks in der Zeile ersetzt. Wenn die Option „g“ (global) zu einer Regex hinzugefügt wird, werden alle Vorkommen ersetzt, nicht nur das erste

Console.log("Borobudur".replace(//, "a")); // → Barobudur console.log("Borobudur".replace(//g, "a")); // → Barabadar

Es wäre sinnvoll, die Option „Alle ersetzen“ über ein separates Argument oder über eine separate Methode wie „replaceAll“ zu übergeben. Aber leider wird die Option über das reguläre System selbst übertragen.

Die volle Leistungsfähigkeit regulärer Ausdrücke zeigt sich, wenn wir Links zu Gruppen verwenden, die in einer im regulären Ausdruck angegebenen Zeichenfolge gefunden werden. Wir haben zum Beispiel eine Zeile mit den Namen von Personen, einen Namen pro Zeile, im Format „Nachname, Vorname“. Wenn wir sie vertauschen und das Komma entfernen müssen, um „Vorname Nachname“ zu erhalten, schreiben wir Folgendes:

Console.log("Hopper, Grace\nMcCarthy, John\nRitchie, Dennis" .replace(/([\w ]+), ([\w ]+)/g, "$2 $1")); // → Grace Hopper // John McCarthy // Dennis Ritchie

$1 und $2 in der Ersetzungszeile beziehen sich auf in Klammern eingeschlossene Zeichengruppen. $1 wird durch den Text ersetzt, der der ersten Gruppe entspricht, $2 durch den Text der zweiten Gruppe usw. bis zu $9. Die gesamte Übereinstimmung ist in der Variablen $& enthalten.

Sie können auch eine Funktion als zweites Argument übergeben. Für jede Ersetzung wird eine Funktion aufgerufen, deren Argumente die gefundenen Gruppen (und der gesamte übereinstimmende Teil der Zeile) sind, und ihr Ergebnis wird in eine neue Zeile eingefügt.

Einfaches Beispiel:

Var s = „CIA und FBI“; console.log(s.replace(/\b(fbi|cia)\b/g, function(str) ( return str.toUpperCase(); ))); // → die CIA und das FBI

Hier ist etwas Interessanteres:

Var stock = „1 Zitrone, 2 Kohlköpfe und 101 Eier“; function minusOne(match, amount, unit) ( amount = Number(amount) - 1; if (amount == 1) // nur noch einer übrig, entferne das „s“ am Ende unit = unit.slice(0, unit. length - 1); else if (amount == 0) amount = "no"; return amount + " " + unit ) console.log(stock.replace(/(\d+) (\w+)/g, minusOne) ); // → keine Zitrone, 1 Kohl und 100 Eier

Der Code nimmt eine Zeichenfolge, findet alle Vorkommen von Zahlen gefolgt von einem Wort und gibt eine Zeichenfolge zurück, wobei jede Zahl um eins reduziert wird.

Die Gruppe (\d+) geht in das Mengenargument und (\w+) in das Einheitenargument ein. Die Funktion wandelt den Betrag in eine Zahl um – und das funktioniert immer, denn unser Muster ist \d+. Und nimmt dann Änderungen am Wort vor, falls nur noch 1 Element übrig ist.

Gier

Funktion stripComments(code) ( return code.replace(/\/\/.*|\/\*[^]*\*\//g, ""); ) console.log(stripComments("1 + /* 2 */3")); // → 1 + 3 console.log(stripComments("x = 10;// ten!")); // → x = 10; console.log(stripComments("1 /* a */+/* b */ 1")); // → 1 1

Der Teil vor dem „oder“-Operator entspricht zwei Schrägstrichen, gefolgt von einer beliebigen Anzahl von Zeichen außer Zeilenumbrüchen. Der Teil, der mehrzeilige Kommentare entfernt, ist komplexer. Wir verwenden [^], d.h. jedes Zeichen, das nicht leer ist, um ein beliebiges Zeichen zu finden. Wir können keinen Punkt verwenden, da Blockkommentare in einer neuen Zeile fortgesetzt werden und das Zeilenumbruchzeichen nicht mit dem Punkt übereinstimmt.

Die Ausgabe des vorherigen Beispiels ist jedoch falsch. Warum?

Der Teil [^]* versucht zunächst, so viele Zeichen wie möglich zu erfassen. Wenn der nächste Teil der regulären Sequenz aus diesem Grund keine Übereinstimmung findet, wird ein Zeichen zurückgesetzt und es erneut versucht. Im Beispiel versucht der Algorithmus, die gesamte Zeile zu erfassen und führt dann einen Rollback durch. Nachdem er 4 Zeichen zurückgesetzt hat, findet er */ in der Zeile – und das ist nicht das, was wir wollten. Wir wollten nur einen Kommentar erfassen und nicht bis zum Ende der Zeile gehen und den letzten Kommentar finden.

Aus diesem Grund sagen wir, dass die Wiederholungsoperatoren (+, *, ? und ()) gierig sind, was bedeutet, dass sie sich zuerst so viel wie möglich schnappen und dann zurückgehen. Wenn Sie nach einem Operator wie diesem (+?, *?, ??, ()?) eine Frage stellen, werden sie nicht gierig und beginnen, die kleinstmöglichen Vorkommen zu finden.

Und das ist es, was wir brauchen. Indem wir das Sternchen zwingen, Übereinstimmungen mit der geringstmöglichen Anzahl von Zeichen in einer Zeile zu finden, verbrauchen wir nur einen Kommentarblock und nichts weiter.

Funktion stripComments(code) ( return code.replace(/\/\/.*|\/\*[^]*?\*\//g, ""); ) console.log(stripComments("1 /* a */+/* b */ 1")); // → 1 + 1

Bei der Verwendung gieriger Operatoren anstelle nicht gieriger Operatoren treten viele Fehler auf. Wenn Sie den Wiederholungsoperator verwenden, berücksichtigen Sie immer zuerst den nicht gierigen Operator.

RegExp-Objekte dynamisch erstellen

Sie können die Zeichenfolge jedoch erstellen und den RegExp-Konstruktor verwenden. Hier ist ein Beispiel:

Var-Name = „Harry“; var text = „Und Harry hat eine Narbe auf seiner Stirn.“; var regexp = new RegExp("\\b(" + name + ")\\b", "gi"); console.log(text.replace(regexp, "_$1_")); // → Und _Harry_ hat eine Narbe auf seiner Stirn.

Beim Erstellen von Wortgrenzen müssen wir doppelte Schrägstriche verwenden, da wir diese in einer normalen Zeile schreiben und nicht in einer regelmäßigen Reihenfolge mit Schrägstrichen. Das zweite Argument von RegExp enthält Optionen für reguläre Ausdrücke – in unserem Fall „gi“, also global und ohne Berücksichtigung der Groß-/Kleinschreibung.

Was aber, wenn der Name „dea+hlrd“ lautet (wenn unser Benutzer ein Kulhatzker ist)? Als Ergebnis erhalten wir einen bedeutungslosen regulären Ausdruck, der keine Übereinstimmungen in der Zeichenfolge findet.

Wir können vor jedem Zeichen, das uns nicht gefällt, Backslashes hinzufügen. Wir können vor Buchstaben keine Backslashes einfügen, da \b oder \n Sonderzeichen sind. Sie können jedoch problemlos Schrägstriche vor allen nicht alphanumerischen Zeichen einfügen.

Var name = "dea+hlrd"; var text = „Dieser Dea+hlrd nervt alle.“; var escaped = name.replace(/[^\w\s]/g, "\\$&"); var regexp = new RegExp("\\b(" + escaped + ")\\b", "gi"); console.log(text.replace(regexp, "_$1_")); // → Dieses _dea+hlrd_ hat alle genervt.

Suchmethode

Console.log(" word".search(/\S/)); // → 2 console.log(" ".search(/\S/)); // → -1

Leider gibt es keine Möglichkeit, die Methode anzuweisen, ab einem bestimmten Offset nach einer Übereinstimmung zu suchen (wie Sie es mit indexOf tun können). Das wäre hilfreich.

lastIndex-Eigenschaft

Ein Regex-Objekt hat Eigenschaften. Eine davon ist „source“, die eine Zeichenfolge enthält. Ein anderer ist lastIndex, der unter bestimmten Bedingungen steuert, wo die nächste Suche nach Vorkommen beginnt.

Zu diesen Bedingungen gehört, dass die globale Option g vorhanden sein muss und dass die Suche mit der Methode exec durchgeführt werden muss. Eine vernünftigere Lösung wäre es, einfach die Übergabe eines zusätzlichen Arguments an exec zuzulassen, aber Vernünftigkeit ist kein grundlegendes Merkmal der JavaScript-Regex-Schnittstelle.

Var-Muster = /y/g; pattern.lastIndex = 3; var match = pattern.exec("xyzzy"); console.log(match.index); // → 4 console.log(pattern.lastIndex); // → 5

Wenn die Suche erfolgreich war, aktualisiert der Exec-Aufruf die lastIndex-Eigenschaft so, dass sie auf die Position nach dem gefundenen Vorkommen zeigt. War kein Erfolg, wird lastIndex auf Null gesetzt – genau wie der lastIndex des neu erstellten Objekts.

Bei Verwendung einer globalen regulären Variablen und mehrerer Exec-Aufrufe können diese automatischen LastIndex-Aktualisierungen Probleme verursachen. Ihr regulärer Server kann mit der Suche an der Position beginnen, die beim vorherigen Aufruf übrig geblieben ist.

Var digit = /\d/g; console.log(digit.exec("hier ist es: 1")); // → ["1"] console.log(digit.exec("and now: 1")); // → null

Ein weiterer interessanter Effekt der g-Option besteht darin, dass sie die Funktionsweise der Match-Methode ändert. Wenn es mit dieser Option aufgerufen wird, wird kein Array zurückgegeben, das dem Ergebnis von exec ähnelt, sondern alle Vorkommen des Musters in der Zeichenfolge werden gefunden und ein Array der gefundenen Teilzeichenfolgen zurückgegeben.

Console.log("Banana".match(/an/g)); // → ["an", "an"]

Seien Sie also vorsichtig mit globalen regulären Variablen. Die Fälle, in denen sie benötigt werden – Ersetzungsaufrufe oder Orte, an denen Sie lastIndex speziell verwenden – sind wahrscheinlich alle Fälle, in denen sie verwendet werden sollten.

Vorkommenszyklen

Eine typische Aufgabe besteht darin, alle Vorkommen eines Musters in einer Zeichenfolge zu durchlaufen, damit es mithilfe von lastIndex und exec auf das Übereinstimmungsobjekt im Schleifenkörper zugreifen kann.

Var input = „Eine Zeile mit 3 Zahlen darin … 42 und 88.“; var number = /\b(\d+)\b/g; var-Match; while (match = number.exec(input)) console.log("Gefunden", match, "on", match.index); // → Gefunden 3 mal 14 // Gefunden 42 mal 33 // Gefunden 88 mal 40

Es macht sich die Tatsache zunutze, dass der Wert der Zuweisung der Wert ist, der zugewiesen wird. Indem wir match = re.exec(input) als Bedingung in einer while-Schleife verwenden, suchen wir zu Beginn jeder Iteration, speichern das Ergebnis in einer Variablen und beenden die Schleife, wenn alle Übereinstimmungen gefunden wurden.

Parsen von INI-Dateien

Zum Abschluss des Kapitels schauen wir uns ein Problem bei der Verwendung regulärer Ausdrücke an. Stellen Sie sich vor, wir schreiben ein Programm, das automatisch Informationen über unsere Feinde über das Internet sammelt. (Wir werden nicht das gesamte Programm schreiben, sondern nur den Teil, der die Einstellungsdatei liest. Entschuldigung.) Die Datei sieht folgendermaßen aus:

Searchengine=http://www.google.com/search?q=$1 boshaftigkeit=9.7 ; vor Kommentaren wird ein Semikolon gesetzt; Jeder Abschnitt bezieht sich auf einen anderen Feind, vollständiger Name=Larry Doe, Typ=Kindergartenbulle, Website=http://www.geocities.com/CapeCanaveral/11451, vollständiger Name=Gargamel, Typ=böser Zauberer, Ausgabedir=/home/marijn/enemies/gargamel

Das genaue Dateiformat (das weit verbreitet ist und normalerweise als INI bezeichnet wird) ist wie folgt:

Leerzeilen und Zeilen, die mit einem Semikolon beginnen, werden ignoriert
- Zeilen in eckigen Klammern beginnen einen neuen Abschnitt
– Zeilen, die eine alphanumerische Kennung enthalten, gefolgt von =, fügen Sie in diesem Abschnitt eine Einstellung hinzu

Alles andere sind falsche Daten.

Unsere Aufgabe besteht darin, einen solchen String in ein Array von Objekten umzuwandeln, jedes mit einer Namenseigenschaft und einem Array von Einstellungen. Für jeden Abschnitt wird ein Objekt benötigt, und ein weiteres wird für globale Einstellungen über der Datei benötigt.

Da die Datei Zeile für Zeile analysiert werden muss, empfiehlt es sich, die Datei zunächst in Zeilen aufzuteilen. Dazu haben wir in Kapitel 6 string.split("\n") verwendet. Einige Betriebssysteme verwenden nicht ein \n-Zeichen für Zeilenumbrüche, sondern zwei – \r\n. Da die Split-Methode reguläre Ausdrücke als Argument verwendet, können wir Zeilen mit dem Ausdruck /\r?\n/ teilen, wodurch sowohl einzelne \n als auch \r\n zwischen Zeilen zulässig sind.

Funktion parseINI(string) ( // Beginnen wir mit einem Objekt, das Einstellungen der obersten Ebene enthält. var currentSection = (name: null, Felder: ); var columns = ; string.split(/\r?\n/).forEach(function (line ) ( var match; if (/^\s*(;.*)?$/.test(line)) ( return; ) else if (match = line.match(/^\[(.*)\ ]$ /)) ( currentSection = (name: match, Felder: ); Kategorien.push(currentSection); ) else if (match = line.match(/^(\w+)=(.*)$/)) ( currentSection.fields.push((name: match, value: match)); else ( throw new Error("Die Zeile "" + line + "" enthält ungültige Daten."); ) ));

Der Code durchläuft alle Zeilen und aktualisiert das aktuelle Abschnittsobjekt „aktueller Abschnitt“. Zunächst wird geprüft, ob die Zeile mit dem regulären Ausdruck /^\s*(;.*)?$/ ignoriert werden kann. Können Sie sich vorstellen, wie das funktioniert? Der Teil zwischen den Klammern passt zu den Kommentaren, oder? sorgt dafür, dass das reguläre Zeichen auch mit Zeilen übereinstimmt, die nur aus Leerzeichen bestehen.

Wenn es sich bei der Zeile nicht um einen Kommentar handelt, prüft der Code, ob ein neuer Abschnitt beginnt. Wenn ja, wird ein neues Objekt für den aktuellen Abschnitt erstellt, dem nachfolgende Einstellungen hinzugefügt werden.

Die letzte sinnvolle Möglichkeit besteht darin, dass es sich bei der Zeichenfolge um eine normale Einstellung handelt. In diesem Fall wird sie dem aktuellen Objekt hinzugefügt.

Wenn keine der Optionen funktioniert, gibt die Funktion einen Fehler aus.

Beachten Sie, dass durch die häufige Verwendung von ^ und $ sichergestellt wird, dass der Ausdruck mit der gesamten Zeichenfolge und nicht nur mit einem Teil davon übereinstimmt. Wenn Sie sie nicht verwenden, funktioniert der Code im Allgemeinen, führt jedoch manchmal zu seltsamen Ergebnissen und der Fehler ist schwer aufzuspüren.

Das Konstrukt if (match = string.match(...)) ähnelt dem Trick, eine Zuweisung als Bedingung in einer While-Schleife zu verwenden. Oft wissen Sie nicht, ob der Match-Aufruf erfolgreich sein wird, sodass Sie nur auf das Ergebnisobjekt innerhalb eines if-Blocks zugreifen können, der danach sucht. Um die schöne Kette der if-Prüfungen nicht zu unterbrechen, weisen wir das Suchergebnis einer Variablen zu und verwenden diese Zuweisung sofort als Prüfung.

Internationale Symbole

In einer seltsamen Wendung stimmt \s (Leerzeichen) historisch mit allen Zeichen überein, die in Unicode als Leerzeichen gelten, einschließlich Dingen wie dem geschützten Leerzeichen oder dem mongolischen Vokaltrennzeichen.

Einige Regex-Implementierungen in anderen Sprachen verfügen über eine spezielle Syntax für die Suche nach speziellen Kategorien von Unicode-Zeichen, z. B. „alle Großbuchstaben“, „alle Satzzeichen“ oder „Steuerzeichen“. Es gibt Pläne, solche Kategorien zu JavaScript hinzuzufügen, aber sie werden wahrscheinlich nicht bald implementiert.

Fazit

Reguläre Objekte sind Objekte, die Suchmuster in Zeichenfolgen darstellen. Sie verwenden ihre eigene Syntax, um diese Muster auszudrücken.

/abc/ Zeichenfolge
// Beliebiges Zeichen aus der Liste
/[^abc]/ Beliebiges Zeichen außer den Zeichen aus der Liste
// Beliebiges Zeichen aus dem Intervall
/x+/ Ein oder mehrere Vorkommen des Musters x
/x+?/ Ein oder mehrere Vorkommen, nicht gierig
/x*/ Null oder mehr Vorkommen
/x?/ Null oder ein Vorkommen
/x(2,4)/ Von zwei bis vier Vorkommen
/(abc)/ Gruppe
/a|b|c/ Eines von mehreren Mustern
/\d/ Beliebige Zahl
/\w/ Beliebiges alphanumerisches Zeichen („Buchstabe“)
/\s/ Beliebiges Leerzeichen
/./ Beliebiges Zeichen außer Zeilenumbrüchen
/\b/ Wortgrenze
/^/ Zeilenanfang
/$/ Ende der Zeile

Der reguläre Ausdruck verfügt über eine Testmethode, um zu prüfen, ob das Muster in der Zeichenfolge enthalten ist. Es gibt eine exec-Methode, die ein Array zurückgibt, das alle gefundenen Gruppen enthält. Das Array verfügt über eine Indexeigenschaft, die die Nummer des Zeichens enthält, bei dem die Übereinstimmung aufgetreten ist.

Zeichenfolgen verfügen über eine Match-Methode zum Abgleichen von Mustern und eine Suchmethode, die nur die Startposition des Vorkommens zurückgibt. Die Methode „replace“ kann Vorkommen eines Musters durch eine andere Zeichenfolge ersetzen. Darüber hinaus können Sie eine Funktion zum Ersetzen übergeben, die eine Ersetzungszeile basierend auf der Vorlage und den gefundenen Gruppen erstellt.

Reguläre Zeichen haben Einstellungen, die nach dem schließenden Schrägstrich geschrieben werden. Die i-Option macht den regulären Ausdruck unabhängig von der Groß-/Kleinschreibung und die g-Option macht ihn global, was unter anderem dazu führt, dass die replace-Methode alle gefundenen Vorkommen ersetzt, nicht nur das erste.

Mit dem RegExp-Konstruktor können reguläre Ausdrücke aus Strings erstellt werden.

Atemregler sind scharfe Instrumente mit einem unbequemen Griff. Sie vereinfachen einige Aufgaben erheblich und können bei der Lösung anderer, komplexer Probleme unüberschaubar werden. Ein Teil des Erlernens der Verwendung regulärer Ausdrücke besteht darin, der Versuchung widerstehen zu können, sie mit einer Aufgabe vollzustopfen, für die sie nicht gedacht sind.

Übungen

Regelmäßiges Golfen

Schreiben Sie für jede Unterzeile einen regulären Ausdruck, um deren Position in der Zeile zu überprüfen. Die reguläre Engine sollte nur diese angegebenen Teilzeichenfolgen finden. Machen Sie sich keine Sorgen über Wortgrenzen, es sei denn, dies wird ausdrücklich erwähnt. Wenn Sie ein funktionierendes regelmäßiges Muster haben, versuchen Sie, es zu reduzieren.

Auto und Katze
- Pop und Requisiten
- Frettchen, Fähre und Ferrari
- Jedes Wort, das auf ious endet
- Ein Leerzeichen, gefolgt von einem Punkt, Komma, Doppelpunkt oder Semikolon.
- Ein Wort, das länger als sechs Buchstaben ist
- Wort ohne Buchstaben e

// Geben Sie Ihre regulären Ausdrücke ein verify(/.../, ["my car", "bad cats"], ["camper", "high art"]); überprüfen(/.../, ["pop culture", "mad props"], ["plop"]); überprüfen(/.../, ["freret", "ferry", "ferrari"], ["ferrum", "transfer A"]); überprüfen(/.../, ["wie lecker", "geräumiger Raum"], ["ruinös", "Bewusstsein"]); überprüfen(/.../, ["schlechte Interpunktion ."], ["escape the dot"]); überprüfen(/.../, ["hottenottententen"], ["no", "hotten totten tenten"]); überprüfen(/.../, ["rotes Schnabeltier", "wackelndes Nest"], ["Erdbett", "lernender Affe"]); function verify(regexp, yes, no) ( // Unvollendete Übungen ignorieren if (regexp.source == "...") return; yes.forEach(function(s) ( if (!regexp.test(s)) console .log("Nicht gefunden "" + s + """ )); no.forEach(function(s) ( if (regexp.test(s)) console.log("Unerwartetes Vorkommen "" + s + " "" ); ));

Zitate im Text

Überlegen Sie sich ein Muster, das zwischen diesen beiden Verwendungen von Anführungszeichen unterscheidet, und schreiben Sie einen Aufruf an die Ersetzungsmethode, die die Ersetzung durchführt.

Wieder Zahlen

Schreiben Sie einen Ausdruck, der nur im JavaScript-Stil geschriebene Zahlen findet. Es muss ein mögliches Minus oder Plus vor der Zahl, einen Dezimalpunkt und die wissenschaftliche Schreibweise 5e-3 oder 1E10 unterstützen – wiederum mit einem möglichen Plus oder Minus. Beachten Sie außerdem, dass vor oder nach dem Punkt nicht unbedingt Zahlen stehen müssen, die Zahl aber nicht aus einem einzelnen Punkt bestehen darf. Das heißt, .5 oder 5. sind gültige Zahlen, ein Punkt allein jedoch nicht.

// Geben Sie hier die reguläre Reihenfolge ein. var number = /^...$/; // Tests: ["1", "-1", "+15", "1.55", ".5", "5.", "1.3e2", "1E-4", "1e+12"] .forEach(function(s) ( if (!number.test(s)) console.log("Did not find "" + s + """); )); ["1a", "+-1", "1.2.3", "1+1", "1e4.5", ".5.", "1f5", "."].forEach(function(s) ( if (number.test(s)) console.log("Falsch akzeptiert "" + s + """); ));

Dieser Artikel behandelt die Grundlagen der Verwendung regulärer Ausdrücke in Javascript.

Einführung

Was ist ein regulärer Ausdruck?

Ein regulärer JS-Ausdruck ist eine Zeichenfolge, die eine Suchregel bildet. Diese Regel kann dann zum Durchsuchen von Text sowie zum Ersetzen verwendet werden. In der Praxis kann ein regulärer Ausdruck sogar aus einem einzelnen Zeichen bestehen, häufiger sind jedoch komplexere Suchmuster.

In Javascript sind reguläre Ausdrücke ebenfalls Objekte. Hierbei handelt es sich um Muster, mit denen Zeichenfolgen in Zeichenfolgen abgeglichen werden. Sie werden in den Methoden exec() und test() des RegExp-Objekts sowie in den Methoden match(), replace(), search und split() des String-Objekts verwendet.

Beispiel

var Muster = /example/i

/example/i ist ein regulärer Ausdruck. Beispiel ist eine Vorlage ( welches bei der Suche verwendet wird). i ist ein Modifikator, der die Groß-/Kleinschreibung angibt.

Vorbereiten eines regulären Ausdrucks

Reguläre JS-Ausdrücke bestehen aus einem Muster und einem Modifikator. Die Syntax wird etwa so aussehen:

/pattern/modifikatoren;

Die Vorlage gibt die Suchregel an. Es besteht aus einfachen Zeichen wie /abc/ oder einer Kombination aus einfachen und Sonderzeichen: /abc/ oder /Chapter (d+).d/ .

Vorlagentabelle

Mithilfe von Modifikatoren können Sie bei Abfragen die Groß-/Kleinschreibung berücksichtigen, sie global usw. festlegen. Sie werden zur Durchführung von Suchen unter Berücksichtigung der Groß- und Kleinschreibung sowie von globalen Suchen verwendet.

Modifikatortabelle

Jetzt sind wir bereit, reguläre JS-Ausdrücke anzuwenden. Hierfür gibt es im Wesentlichen zwei Möglichkeiten: die Verwendung eines regulären Ausdrucksobjekts oder eines regulären Ausdrucks für eine Zeichenfolge.

Verwendung eines regulären Ausdrucksobjekts

Erstellen Sie ein reguläres Ausdrucksobjekt

Dieses Objekt beschreibt ein Zeichenmuster. Es wird zum Mustervergleich verwendet. Es gibt zwei Möglichkeiten, ein reguläres Ausdrucksobjekt zu erstellen.

Methode 1: Verwenden eines regulären Ausdrucksliterals, das aus einem in Schrägstrichen eingeschlossenen Muster besteht, zum Beispiel:

var reg = /ab+c/;

Literale regulärer Ausdrücke lösen beim Parsen des Skripts eine Vorkompilierung des regulären Ausdrucks aus. Wenn der reguläre Ausdruck konstant ist, verwenden Sie ihn, um die Leistung zu verbessern.

Methode 2: Aufruf der Konstruktorfunktion des RegExp-Objekts, zum Beispiel:

var reg = new RegExp("ab+c");

Durch die Verwendung eines Konstruktors kann der reguläre JS-Ausdruck kompiliert werden, während das Skript ausgeführt wird. Verwenden Sie diese Methode, wenn sich der reguläre Ausdruck ändert oder Sie das Muster nicht im Voraus kennen. Wenn Sie beispielsweise Informationen von einem Benutzer erhalten, der eine Suchanfrage eingibt.

Objektmethoden für reguläre Ausdrücke

Werfen wir einen Blick auf einige gängige Objektmethoden für reguläre Ausdrücke:

• kompilieren() ( in Version 1.5 veraltet) – kompiliert einen regulären Ausdruck;
• exec() – Führt einen String-Abgleich durch. Gibt die erste Übereinstimmung zurück;
• test() – führt einen Abgleich mit einer Zeichenfolge durch. Gibt true oder false zurück;
• toString() – gibt den String-Wert des regulären Ausdrucks zurück.

Beispiele

Verwendung von test()

Die test()-Methode ist ein regulärer Ausdruck des RegExp-Objekts. Es sucht nach einer Musterzeichenfolge und gibt je nach Ergebnis „true“ oder „false“ zurück. Das folgende Beispiel für einen regulären JS-Ausdruck zeigt, wie eine Zeichenfolge nach dem Zeichen „ durchsucht wird. e”:

var patt = /e/; patt.test("Die besten Dinge der Welt sind kostenlos!");

Denn hier in der Zeile steht „ e“, wird das Ergebnis dieses Codes wahr sein.

Reguläre Ausdrücke müssen nicht in einer Variablen platziert werden. Die gleiche Abfrage kann in einer Zeile durchgeführt werden:

/e/.test("Die besten Dinge der Welt sind kostenlos!");

Verwendung von exec()

Es durchsucht eine Zeichenfolge mithilfe einer bestimmten Suchregel und gibt den gefundenen Text zurück. Wenn keine Übereinstimmungen gefunden wurden, ist das Ergebnis null .

Schauen wir uns die Methode in Aktion am Beispiel des gleichen Symbols „ e”:

/e/.exec("Die besten Dinge der Welt sind kostenlos!");

Da die Zeile „ e“, das Ergebnis dieses Codes ist .e .

Anwenden eines regulären Ausdrucks auf eine Zeichenfolge

In Javascript können diese Ausdrücke auch mit zwei Methoden des String-Objekts verwendet werden: search() und replace(). Sie werden zum Suchen und Ersetzen im Text benötigt.

• search()-Methode – verwendet einen Ausdruck, um nach einer Übereinstimmung zu suchen, und gibt Informationen über den Ort der Übereinstimmung zurück;
• Die Methode replace() gibt eine geänderte Zeichenfolge mit einem ersetzten Muster zurück.

Beispiele

Verwenden eines regulären JS-Ausdrucks, um eine Suche unter Berücksichtigung der Groß- und Kleinschreibung nach der Phrase „ durchzuführen w3schools” in der Zeile:

var str = "Besuchen Sie W3Schools"; var n = str.search(/w3schools/i);

Das Ergebnis in n wird 6 sein.

Die Suchmethode akzeptiert auch eine Zeichenfolge als Argument. Das String-Argument wird in einen regulären Ausdruck umgewandelt:

Verwenden Sie eine Zeichenfolge, um nach der Phrase „ zu suchen W3schulen” in der Zeile.

Methode replace() durch regulären Ausdruck ermöglichen Ihnen eine flexible Suche nach Wörtern und Ausdrücken in Texten, um diese zu löschen, zu extrahieren oder zu ersetzen.

Syntax:

//Erste Option zum Erstellen eines regulären Ausdrucks var regexp=new RegExp( Probe,Modifikatoren); //Zweite Option zum Erstellen eines regulären Ausdrucks var regexp=/ Probe/Modifikatoren;

Probe ermöglicht Ihnen die Angabe eines Zeichenmusters für die Suche.

Modifikatoren ermöglichen Ihnen, das Suchverhalten anzupassen:

• ich- Suche ohne Berücksichtigung der Groß-/Kleinschreibung;
• G- globale Suche (alle Treffer im Dokument werden gefunden, nicht nur der erste);
• M- Mehrzeilige Suche.

Suchen Sie nach Wörtern und Ausdrücken

Die einfachste Verwendung regulärer Ausdrücke ist die Suche nach Wörtern und Ausdrücken in verschiedenen Texten.

Hier ist ein Beispiel für die Verwendung der Suche mithilfe von Modifikatoren:

//Setze den regulären Ausdruck rv1 rv1=/Russia/; //Geben Sie den regulären Ausdruck rv2 an rv2=/Russia/g; //Geben Sie den regulären Ausdruck rv3 an rv3=/Russia/ig; //Fett zeigt an, wo im Text Übereinstimmungen zu finden sind, wenn //der Ausdruck rv1 verwendet wird: Russland ist der größte Staat der Welt. Russland grenzt an 18 Länder. RUSSLAND ist ein Nachfolgestaat der UdSSR. //Fett zeigt an, wo im Text Übereinstimmungen zu finden sind, wenn //der Ausdruck rv2 verwendet wird: Russland ist der größte Staat der Welt. Russland grenzt an 18 Länder. RUSSLAND ist ein Nachfolgestaat der UdSSR.“; //Fettschrift zeigt an, wo im Text Übereinstimmungen gefunden werden, wenn //der Ausdruck rv3 verwendet wird: Russland ist der größte Staat der Welt. Russland grenzt an 18 Länder. RUSSLAND ist ein Nachfolgestaat der UdSSR.“;

Sonderzeichen

Zusätzlich zu regulären Zeichen können reguläre Ausdrucksmuster verwendet werden Sonderzeichen(Metazeichen). Sonderzeichen mit Beschreibungen sind in der folgenden Tabelle aufgeführt:

/* Der reg1-Ausdruck findet alle Wörter, die mit zwei beliebigen Buchstaben beginnen und mit „vet“ enden. Da die Wörter im Satz durch ein Leerzeichen getrennt sind, fügen wir am Anfang und am Ende ein Sonderzeichen \s hinzu */ reg1=/\s..vet\s/g; txt="Hallo Bund Cordschrank"; document.write(txt.match(reg1) + "
"); /* Der reg2-Ausdruck findet alle Wörter, die mit drei beliebigen Buchstaben beginnen und mit „vet" enden */ reg2=/\s...vet\s/g; document.write(txt.match(reg2) + "
"); txt1=" hi2hello hi 1hello "; /* Der reg3-Ausdruck findet alle Wörter, die mit „at“ gefolgt von einer Ziffer beginnen und mit „vet“ enden */ var reg3=/at\dvet/g; document . write(txt1.match(reg3) + "
"); // Der Ausdruck reg4 findet alle Zahlen im Text var reg4=/\d/g; txt2="5 Jahre Studium, 3 Jahre Segeln, 9 Jahre Schießen." document.write(txt2. match(reg4) + "
");

Schnellansicht

Symbole in eckigen Klammern

Verwendung von eckigen Klammern [keyu] Sie können eine Gruppe von Zeichen angeben, nach denen gesucht werden soll.

Das Zeichen ^ vor einer Gruppe von Zeichen in eckigen Klammern [^kwg] gibt an, dass Sie nach allen Zeichen des Alphabets suchen müssen, mit Ausnahme der angegebenen.

Verwenden Sie einen Bindestrich (-) zwischen den Zeichen in eckigen Klammern [a-z] Sie können einen Bereich von Zeichen angeben, nach denen gesucht werden soll.

Sie können Zahlen auch mit eckigen Klammern suchen.

//Setze den regulären Ausdruck reg1 reg1=/\sko[tdm]\s/g; //Legen Sie eine Textzeichenfolge fest txt1 txt1=" Cat Braid Code Kommode mit Teppich "; //Suchen Sie mit dem regulären Ausdruck reg1 nach der Zeichenfolge txt1 document.write(txt1.match(reg1) + "
"); reg2=/\sslo[^tg]/g; txt2=" Slot Elephant Silbe "; document.write(txt2.match(reg2) + "
"); reg3=//g; txt3="5 Jahre Studium, 3 Jahre Schwimmen, 9 Jahre Schießen"; document.write(txt3.match(reg3));

Schnellansicht

Quantifizierer

Quantor– Hierbei handelt es sich um eine Konstruktion, mit der Sie angeben können, wie oft das vorhergehende Zeichen oder die vorhergehende Zeichengruppe in einer Übereinstimmung vorkommen soll.

Syntax:

//Vorhergehendes Zeichen muss x-mal vorkommen (X)//Das vorangehende Zeichen muss x- bis einschließlich y-mal vorkommen (x,y)//Das vorangehende Zeichen muss mindestens x-mal vorkommen (X,)//Gibt an, dass das vorhergehende Zeichen 0 oder öfter vorkommen muss * //Gibt an, dass das vorangehende Zeichen mindestens einmal vorkommen muss + //Gibt an, dass das vorangehende Zeichen 0 oder 1 Mal vorkommen muss ?

//Geben Sie den regulären Ausdruck rv1 rv1=/ko(5)shka/g an //Geben Sie den regulären Ausdruck rv2 an rv2=/ko(3,)shka/g //Geben Sie den regulären Ausdruck rv3 an rv3=/ko+shka/g //Geben Sie den regulären Ausdruck rv4 an rv4=/ko?shka/g //Legen Sie den regulären Ausdruck rv5 fest rv5=/ko*shka/g //Fettschrift zeigt an, wo im Text Übereinstimmungen gefunden werden, wenn //der Ausdruck rv1 verwendet wird: kshka cat kooshka koooshka kooooshka kooooshka kooooooshka kooooooshka //Fett zeigt an, wo im Text Übereinstimmungen gefunden werden, wenn //der RV2-Ausdruck verwendet wird: kshka cat kooshka kooooshka kooooshka kooooooshka kooooooshka kooooooshka//Fett zeigt an, wo im Text Übereinstimmungen gefunden werden, wenn //der Ausdruck rv3: kshka verwendet wird Katze kooshka kooooshka kooooshka kooooshka kooooooshka kooooooshka//Fett zeigt an, wo im Text Übereinstimmungen gefunden werden, wenn //der RV4-Ausdruck verwendet wird: kshka Katze kooshka kooooshka kooooshka kooooshka kooooooshka kooooooshka

Bitte beachten Sie: Wenn Sie ein Sonderzeichen (z. B. . * + ? oder ()) wie ein normales Zeichen verwenden möchten, müssen Sie ein \ davor setzen.

Verwendung von Klammern

Indem Sie einen Teil eines regulären Ausdrucksmusters in Klammern setzen, weisen Sie den Ausdruck an, sich die Übereinstimmung zu merken, die dieser Teil des Musters gefunden hat. Die gespeicherte Übereinstimmung kann später in Ihrem Code verwendet werden.

Beispielsweise findet der reguläre Ausdruck /(Dmitry)\sVasiliev/ die Zeichenfolge „Dmitry Vasiliev“ und merkt sich die Teilzeichenfolge „Dmitry“.

Im folgenden Beispiel verwenden wir die Methode replace(), um die Reihenfolge der Wörter im Text zu ändern. Wir verwenden $1 und $2, um auf gespeicherte Übereinstimmungen zuzugreifen.

Var regexp = /(Dmitry)\s(Vasiliev)/; var text = „Dmitri Wassiljew“; var newtext = text.replace(regexp, "$2 $1"); document.write(newtext);

Schnellansicht

Klammern können verwendet werden, um Zeichen vor Quantoren zu gruppieren.