JavaScript/Objekte/RegExp

Aus SELFHTML-Wiki
Wechseln zu: Navigation, Suche

RegExp, reguläre Ausdrücke dienen dazu, Suchausdrücke zu formulieren, um in Zeichenketten nach Entsprechungen zu suchen und gefundene Stellen durch andere zu ersetzen.

Inhaltsverzeichnis

[Bearbeiten] Eigenschaften


[Bearbeiten] Allgemeines zur Verwendung

Reguläre Ausdrücke können Sie in JavaScript direkt innerhalb entsprechender Methoden des String-Objekts anwenden:

Das RegExp-Objekt von JavaScript brauchen Sie dagegen nur, wenn Sie reguläre Ausdrücke zur Laufzeit des Scripts dynamisch erzeugen und ändern wollen. Dazu können Sie eine Instanz eines RegExp-Objekts definieren.
Auf diese Instanz können Sie anschließend die Eigenschaften und Methoden des RegExp-Objekts anwenden, die hier beschrieben werden.

[Bearbeiten] Reguläre Ausdrücke definieren

Das window.RegExp-Objekt kapselt sogenannte Reguläre Ausdrücke. Darunter versteht man die Möglichkeit, regelmäßige Suchmuster zu definieren und darauf zu testen, danach zu suchen oder Ersetzungen vorzunehmen. Das Objekt definiert nicht nur das Suchpattern, es enthält auch die zur Abfrage notwendigen Ergebnisinformationen eines Tests.

Sie sind aber nicht darauf eingeschränkt, mit dem RegExp-Objekt arbeiten zu müssen. Sie können in vielen Fällen auch die einfachere Syntax /pattern/ verwenden.

Beispiel
var myRegExp = new RegExp('[Ss]elfhtml', 'i');
"test".match(myRegExp);
Im Beispiel wird ein Suchpattern in einem RegExp-Objekt definiert. Dieses nimmt als zweiten Parameter den optionalen Modifier entgegen.
var myRegExp = /[Ss]elfhtml/i;
"test".match(myRegExp);
Geläufiger ist jedoch die Variante /pattern/. Der Modifier wird nach dem schließenden Slash notiert.

[Bearbeiten] Syntax

Reguläre Ausdrücke benutzen bestimmte Steuerzeichen, um Wiederholungen und mehrere mögliche Zeichen zu definieren, nach denen gesucht werden kann. Wenn man diese Zeichen als tatsächliches Zeichen verwenden will, muss man einen Backslash davorstellen.

Beispiel
.
findet ein beliebiges Zeichen
\.
findet einen Punkt


[Bearbeiten] Multiplikatoren

Multiplikator Erläuterung
. sucht jedes beliebige Zeichen.
? das vorstehende Zeichen kommt nicht oder genau einmal vor
* das vorstehende Zeichen kommt nicht oder beliebig oft vor
+ das vorstehende Zeichen kommt mindestens einmal vor
{n} das vorstehende Zeichen kommt genau n mal vor
{n, m} das vorstehende Zeichen kommt n bis m mal vor
{n,} das vorstehende Zeichen kommt mindestens n mal vor

[Bearbeiten] Gierigkeit

Standardmäßig werden Multiplikatoren, die beliebig viele Zeichen erfassen können, auch die größtmögliche Anzahl an Zeichen erfassen (also gierig sein). Folgendes Beispiel illustriert dieses Verhalten:

Beispiel
text.match(/<a.*>/g)
Dieser Ausdruck soll einzelne Starttags von Link-Elementen erkennen.

(Suche nach Zeichenfolgen, die mit „<a“ beginnen, gefolgt von beliebig vielen Zeichen und mit „>“ enden.)

Angewendet auf
var text = '<a href="#test1">test1</a>'
wird jedoch das komplette Link-Element zurückgegegeben.

Das Suchmuster trifft nämlich sowohl auf

 <a href="#test1">

als auch auf

 <a href="#test1">test1</a>

zu.

Es wurde die längste der möglichen Zeichenketten zurückgeliefert.

Abhilfe liefert der Non-Greedy-Quantifier ?.

Beispiel
text.match(/<a.*?>/g)
Jetzt wird das erste Auftreten des Suchmusters zurückgegeben. Ein nachgestelltes Fragezeichen macht jeden Quantifier "non-greedy" (nicht gierig).

[Bearbeiten] Zeichenklassen

Zeichenklassen definieren Gruppen von Zeichen, die auftreten müssen bzw. nicht auftreten dürfen. Innerhalb von Zeichenklassen müssen nur die Zeichen "[", "]" und "^" mit einem Backslash gesichert werden. Zusätzlich gibt es vordefinierte Zeichenklassen.

Zeichenklasse Erläuterung
. findet 1 beliebiges Zeichen ausser \n
[12] findet die Ziffer 1 oder 2
[0-9] findet Zeichen von 0-9 (Die Folgen beziehen sich auf die Zeichentabelle innerhalb der gegenwärtigen Kodierung)
[^123] findet Zeichen, die nicht 1, 2 oder 3 sind.
\s Platzhalter-Zeichen (Leerzeichen, Umbrüche und Tabulatoren, entspricht [ \f\n\r\t\v])
\S alles ausser Platzhalter-Zeichen ([^ \f\n\r\t\v])
\d Dezimal numerische Zeichen ([0-9])
\D alles ausser dezimal numerischen Zeichen ([^0-9])
\w Alphanumerische Zeichen und der Unterstrich ([0-9a-zA-Z_])
\W alles ausser alphanumerischen Zeichen bzw. Unterstrich ([^0-9a-zA-Z_])
\b findet eine Wort-Trennstelle, d.h. zwischen \w und \W bzw. umgekehrt.
\B Umkehrung von \b. Findet die Stelle zwischen \w und \w bzw. die Stelle zwischen \W und \W
^ Anfang des Strings (beim m-Modifikator Anfang jeder Zeile)
$ Ende des Strings (beim m-Modifikator Ende jeder Zeile)
\n Newline-Zeichen
\r Wagenrücklauf-Zeichen
\t horizontaler Tabulator
\v vertikaler Tabulator
\cXXX Kodiertes Steuerzeichen
\xXX Kodiertes Ascii-Zeichen
\uXXXX Kodiertes Unicode-Zeichen

[Bearbeiten] Klammern

Innerhalb von Regulären Ausdrücken kann man bestimmte Bereiche einklammern. Dabei wird zwischen Klammern, welche übereinstimmende Ausdrücke in $1..$9 speichern, und nicht speichernden Klammern unterschieden.

Beispiel
/startpattern(.*?)endpattern/
Im Beispiel wird alles zwischen Start und Ende in $1 gespeichert.
/(?:Herr|Frau)\s+(\w+)/
Die Alternative „Herr“ oder „Frau“ wird nicht gespeichert. Die Klammer (?: )dient lediglich der Gruppierung. Der zweite Klammerausdruck hingegen wird sehr wohl gespeichert.
"xy".match(/x(?=y)/); // true
"xz".match(/x(?=y)/); // false
"x".match(/x(?=y)/);  // false
Die positive lookahead Klammer (?= lookaheadpattern ) bewirkt, dass „x“ nur getroffen wird, wenn es von „y“ gefolgt wird.
"xy".match(/x(?!y)/); // false
"xz".match(/x(?!y)/); // true
"x".match(/x(?!y)/);  // true
Die negative lookahead Klammer (?! lookaheadpattern ) bewirkt, dass „x“ nur getroffen wird, wenn es nicht von „y“ gefolgt wird.
Beispiel
<html>
<head>
  <title>Test</title>

  <script type="text/javascript">

    function Ausgabe (Wert) {
var Ausdruck = /(\w.+)\s(\w.+)/;
Ausdruck.exec(Wert);
alert(RegExp.$2 + ", " + RegExp.$1);
    }
  </script>

</head>
<body>
<form action="">
<input type="text" name="User" value="Vorname Zuname">
<input type="button" value="Ausgabe" onclick="Ausgabe(this.form.User.value)">
</form>
</body>
</html>

Das Beispiel zeigt, wie sich ein Name nach dem Schema "Vorname Zuname" unter Verwendung eines regulären Ausdrucks in das Schema "Name, Vorname" verwandeln lässt.

Das Beispiel enthält ein Formular mit einem Eingabefeld und einem Button. In dem Eingabefeld soll der Anwender seinen Namen in der Form "Vorname Zuname" eingeben. Deshalb ist das Feld auch schon so vorbelegt. Beim Anklicken des Buttons wird die Funktion Ausgabe() aufgerufen, die im Dateikopf definiert ist. Als Parameter bekommt die Funktion den Inhalt des Eingabefeldes übergeben.

Innerhalb der Funktion wird ein regulärer Ausdruck (Suchausdruck) definiert, der in der Variablen Ausdruck gespeichert wird. Solche regulären Ausdrücke werden in einfache Schrägstriche /.../ eingeschlossen. Der reguläre Ausdruck im obigen Beispiel ist so zu lesen: Suche nach einer beliebigen Anzahl von aneinandergereihten Buchstaben ohne Ziffern und Satzzeichen und merke dir das Ergebnis (\w.+). Suche dann nach einem einzelnen Leerzeichen = \s. Suche dann noch einmal nach einer beliebigen Buchstabenreihenfolge und merke dir das Ergebnis (\w.+). Auf diese Weise wird das Schema "Vorname Zuname" gefunden. Die beiden Klammern um (\w.+) führen dazu, dass die beiden einzelnen Buchstabenreihenfolgen als einzelne Teile intern gemerkt werden. Später sind diese einzelnen gemerkten Teile separat ansprechbar.

Im Beispiel wird mit dem nächsten Befehl eine wichtige Methode des RegExp-Objekts auf den zuvor definierten regulären Ausdruck angewendet, nämlich die Methode exec(). Dadurch wird der Ausdruck "ausgeführt" und direkt dem RegExp-Objekt zugewiesen. Im Beispiel wird mit RegExp.$2 direkt auf den intern gespeicherten Treffers des zweiten geklammerten Teilausdrucks zugegriffen, und mit RegExp.$1 auf den Treffer des ersten Teilausdrucks. Durch die Anordnung mit dem Komma dazwischen bei der Ausgabe mit alert() erscheint das zuvor eingegebene "Vorname Zuname" dann in dem anderen Schema "Zuname, Vorname".

Beachten Sie: Seit der JavaScript-Version 1.5 gilt das Auslesen der Treffer geklammerten Ausdrücke über RegExp.$1, RegExp.$2 und so weiter als veraltet. In der Praxis steht allerdings nur bei der im Beispiel verwendeten Methode exec() eine Alternative zur Verfügung.


[Bearbeiten] Syntax regulärer Ausdrücke

Die folgende Übersicht zeigt, aus welchen Bestandteilen Sie einen regulären Ausdruck zusammensetzen können.

Bestandteil Beispiel Beschreibung
/aus/ findet "aus" und zwar in "aus", "Haus", "auserlesen" und "Banause".
^ /^aus/ findet "aus" am Anfang des zu durchsuchenden Wertes, also in "aus" und "auserlesen", sofern das die ersten Wörter im Wert sind.
$ /aus$/ findet "aus" am Ende des zu durchsuchenden Wertes, also in "aus" und "Haus", sofern das die letzten Wörter im Wert sind.
* /aus*/ findet "au", "aus", "auss" und "aussssss" also das letzte Zeichen vor dem Stern 0 oder beliebig oft hintereinander wiederholt.
+ /aus+/ findet "auss" und "aussssss" also das letzte Zeichen vor dem Plus-Zeichen mindestens einmal oder beliebig oft hintereinander wiederholt.
. /.aus/ findet "Haus" und "Maus" also ein beliebiges Zeichen an einer bestimmten Stelle.
.+ /.+aus/ findet "Haus" und "Kehraus" also eine beliebige Zeichenfolge an einer bestimmten Stelle. Zusammensetzung aus beliebiges Zeichen und beliebig viele davon, jedoch mindestens eines.
\b /\baus\b/ findet "aus" als einzelnes Wort. \b bedeutet eine Wortgrenze.
\B /\Baus\B/ findet "aus" nur innerhalb von Wörtern,
z.B. in "hausen" oder "Totalausfall".
\B bedeutet keine Wortgrenze.
\d /\d+/ findet eine beliebige ganze Zahl. \d bedeutet eine Ziffer (0 bis 9)
\D /\D+/ findet "-fach" in "3-fach" also keine Ziffer.
\f /\f/ findet ein Seitenvorschubzeichen.  
\n /\n/ findet ein Zeilenvorschub-Zeichen.
\r /\r/ findet ein Wagenrücklaufzeichen.
\t /\t/ findet ein Tabulator-Zeichen.
\v /\v/ findet ein vertikales Tabulator-Zeichen.
\s /\s/ findet jede Art von Weißraum-Zeichen ("Whitespace") also \f, \n, \t, \v und das Leerzeichen.
\S /\S+/ Bfindet ein beliebiges einzelnes Zeichen,
das kein "Whitespace" ist,
also kein \f\n\t\v und kein Leerzeichen.
\w /\w+/ findet alle alphanumerischen Zeichen und den Unterstrich (typische Bedingung etwa für programmiersprachengerechte selbstvergebene Namen).
\W /\W/ findet ein Zeichen, das nicht alphanumerisch und auch kein Unterstrich ist (typisch zum Suchen nach illegalen Zeichen bei programmiersprachengerechten selbstvergebenen Namen)
() /(aus)/ findet "aus" und merkt es sich intern Bis zu 9 solcher Klammern (Merkplätze) sind in einem regulären Ausdruck erlaubt.
/.../g /aus/g findet "aus" so oft wie es in dem gesamten zu durchsuchenden Bereich vorkommt. Die Fundstellen werden intern in einem Array gespeichert.
/.../i /aus/i findet "aus", "Aus" und "AUS", also unabhängig von Groß-/Kleinschreibung.
/.../gi /aus/gi findet "aus", so oft wie es in dem gesamten zu durchsuchenden Bereich vorkommt (g) und unabhängig von Groß-/Kleinschreibung (i).

Umfangreichere Informationen über reguläre Ausdrücke finden Sie Seite reguläre Ausdrücke in Perl.


[Bearbeiten] Tools zum Testen

Meine Werkzeuge
Namensräume

Varianten
Aktionen
Übersicht
Hilfe
SELFHTML
Diverses
Werkzeuge
Flattr
Soziale Netzwerke