| # RegExp
| Allgemeines zur Verwendung ### Eigenschaften: $[1..9] (geklammerte Unterausdrücke) ### Methoden: exec() (Regulären Ausdruck anwenden) test() (Regulären Ausdruck probehalber anwenden)

## Allgemeines zur Verwendung

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

Reguläre Ausdrücke können Sie in JavaScript direkt innerhalb entsprechender Methoden des string-Objekts anwenden. Das trifft auf die Methoden:
match(),
replace() und
search() zu.
Dort wird beschrieben, wie und wo Sie den regulären Ausdruck genau verwenden können, um Zeichenketten zu durchsuchen und Teile darin zu ersetzen.

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.

### Beispiel:

Anzeigebeispiel: So sieht's aus

    <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>

### Erläuterung:

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 zweiten, zuvor intern gemerkten Klammerausdruck zugegriffen, und mit `RegExp.$1` auf den ersten dieser Ausdrücke. 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".

### 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.
`\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.+\B/` | 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 white space, also \f\n\t\v und Leerzeichen.
`\S` | `/\S.+/` | findet ein beliebiges einzelnes Zeichen, das kein white space 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 innerhalb dieser Dokumentation auf der Seite reguläre Ausdrücke in Perl.

## $[1..9]

Speichert die umklammerten Bestandteile eines regulären Ausdrucks. Diese lassen sich benutzen, um bestimmte Teile eines Strings zu extrahieren oder unter Zuhilfenahme der Funktion replace() zu ersetzen.

### Beispiel:

Anzeigebeispiel: So sieht's aus

    <html><head><title>Test</title>
    </head><body>
    <script type="text/javascript">
    var string = "Dies ist ein Verweis nach: http://de.selfhtml.org/";

    var neu = string.replace(/(http:\/\/\S*)/g, '<a href="$1">$1</a>');

    alert("alter String:\n" + string + "\n\nneuer String:\n" + neu + "\n\nDer Verweis lautete: " + RegExp.$1);

    </script>
    </body></html>

### Erläuterung:

Das Beispiel zeigt eine typische Anwendung von replace(). Der Ausdruck sucht in einem String nach einer URL in der Art `http://domain.tld` und ersetzt alle gefundenen Stellen durch einen HTML-Verweis. Das geschieht, indem der Suchausdruck geklammert und dadurch jeweils in $1 gespeichert wird. Mit Hilfe dieses Wertes wird der zu ersetzende String als zweiter Parameter zusammengebaut.
Das Besondere daran ist, dass hier JavaScript im Gegensatz zum üblichen Verhalten innerhalb der Anführungszeichen die Variable $1 übersetzt (oder interpoliert).

### Beachten Sie:

Damit Safari 1.2 einen Wert für `RegExp.$1` erhält, muß zuvor die Methode `exec()` ausgeführt werden. In obigen Beispiel geschieht das nicht.

## exec()

Wendet einen regulären Ausdruck einmalig auf eine Zeichenkette an.

### Beispiel:

Anzeigebeispiel: So sieht's aus

    <html><head><title>Test</title>
    </head><body>
    <script type="text/javascript">
    var derSatz = "Auf der Mauer";
    var Suche = /au/;
    var Ergebnis = Suche.exec(derSatz);
    document.write(Ergebnis.length + " Suchtreffer");
    </script>
    </body></html>

### Erläuterung:

Das Beispiel demonstriert den Zusammenhang: ein regulärer Ausdruck wird definiert, im Beispiel ein regulärer Ausdruck mit dem Namen `Suche`. Mit einer Anweisung wie `Suche.exec()` können Sie dann die Suche starten. Als Parameter wird der Methode in der Regel der zu durchsuchende Ausdruck übergeben. Die Methode gibt einen Array mit den Treffern zurück oder null bei Misserfolg. Das erste Element (mit dem Index 0) ist der erste Teilstring auf den der Sucherausdruck passt, die nachfolgenden Array-Elemente die Teilstrings, die auf eingeklammerte Ausdrucksteile gepasst haben; auf die man innerhalb des regulären Ausdrucks mit \1...\n wiederholt zugreifen kann.

## test()

Testet vorab, ob ein regulärer Ausdruck zu Suchtreffern führt oder nicht. Gibt `true` zurück, wenn etwas gefunden wurde, und `false`, wenn nichts gefunden wurde.

### Beispiel:

Anzeigebeispiel: So sieht's aus

    <html><head><title>Test</title>
    </head><body>
    <script type="text/javascript">
    var derSatz = "Auf der Mauer";
    var Suche = /(sonstwas)/g;
    var Ergebnis = Suche.test(derSatz);
    if (Ergebnis == false)
      document.write("nichts gefunden");
    </script>
    </body></html>

### Erläuterung:

Das Beispiel definiert einen regulären Ausdruck namens `Suche` und wendet ihn mit Hilfe der Methode `test()` auf die Variable `derSatz` an. Der Rückgabewert wird in der Variablen `Ergebnis` gespeichert. Wenn nichts gefunden wird, wird ein entsprechender Hinweis geschrieben. Im Beispiel ist das der Fall.

| screen
| Number

© 2005 Impressum