SELFHTML/Navigationshilfen JavaScript/DOM Objektreferenz
RegExp
Eigenschaften:
$[1..9] (geklammerte Unterausdrücke)
Methoden:
exec() (Regulären Ausdruck anwenden) test() (Regulären Ausdruck probehalber anwenden)
| SELFHTML/Navigationshilfen JavaScript/DOM Objektreferenz |
|
|
RegExp |
|
|
Eigenschaften:
Methoden: exec() (Regulären Ausdruck anwenden) test() (Regulären Ausdruck probehalber anwenden)
|
| | |
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.
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>
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".
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. Näheres entnehmen Sie bitte der Beschreibung von exec().
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.+\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.
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>
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 wird. Im zweiten Parameter, dem Ersatz-String, wird auf den Treffer dieses geklammerten Suchausdrucks mit $1 verwiesen. An der Stelle der Nennung von $1 wird im Beispiel also jeweils der Treffer des Suchausdrucks (http:\/\/\S*) eingefügt, im Beispiel http://de.selfhtml.org/. Falls der Suchausdruck weitere Teile in Klammern erhält, können dessen Treffer im zweiten Parameter entsprechend mit $2, $3 usw. eingefügt werden.
Das Beispiel demonstriert zudem, wie nach dem Ausführen der replace()-Methode auf die Teiltreffer des Suchausdrucks zugegriffen werden kann. Sie werden jeweils als Eigenschaften des globalen RegExp-Objektes erstellt. Mit RegExp.$1 wird der erste Teiltreffer angesprochen, mit RegExp.$2 der zweite und so weiter.
RegExp.$1 und die folgenden Eigenschaften sind in den gängigen Browsern nach jeder Anwendung von regulären Ausdrücken entsprechend gefüllt, sofern Teile des Ausdrucks geklammert sind. Dies betrifft die Methoden match(), replace() und search() von String-Objekten sowie die auf dieser Seite beschriebenen Methoden exec() und test().
Safari und Konqueror bilden eine Ausnahme: Bei den Methoden match() und replace() werden RegExp.$1 und folgende Eigenschaften nicht gefüllt. Im obigen Beispiel gelingt das Auslesen des Teiltreffers in diesen Browsern daher nicht. Es müsste z.B. ausdrücklich exec() ausgeführt werden, um an die Teiltreffer zu kommen.
exec()Wendet einen regulären Ausdruck einmalig auf eine Zeichenkette an und gibt einen Array mit dem Treffer des Gesamtausdrucks sowie die Treffer der geklammerten Teilausdrücke zurück. Wenn der Ausdruck nicht auf die Zeichenkette passt, gibt die Methode null zurück.
Anzeigebeispiel: So sieht's aus
<html><head><title>Test</title>
</head><body>
<script type="text/javascript">
var derSatz = "Auf der Mauer, auf der Lauer sitzt 'ne kleine Wanze.";
var Suche = /der (\w*)(.*)/;
var Ergebnis = Suche.exec(derSatz);
document.write("<p>Originaltext: '<i>" + Ergebnis.input + "<\/i>'<\/p>");
document.write("<p>Treffer des Gesamtausdrucks: '<i>" + Ergebnis[0] +
"<\/i>' an der Position " + Ergebnis.index + "<\/p>");
document.write("<p>Die Treffer der Teilausdrücke im Einzelnen:<\/p>");
document.write("<ol>");
for (var i = 1; i < Ergebnis.length; i++) {
document.write("<li>'<i>" + Ergebnis[i] + "<\/i>'<\/li>");
}
document.write("<\/ol>");
</script>
</body></html>
Das Beispiel demonstriert die Anwendung eines regulären Ausdrucks auf eine Zeichenkette und den umfassenden Zugriff auf die Treffer und Teiltreffer. Zunächst wird ein regulärer Ausdruck mit dem Namen Suche definiert. Er besteht aus dem festen Anfang der gefolgt von einer beliebigen Anzahl von alphanumerischen Zeichen bzw. oder Unterstrichen (\w*). Danach kann eine beliebige Anzahl von beliebigen Zeichen folgen (.*). Um die Teilausdrücke \w* und .* sind jeweils Klammern notiert, sodass später deren Treffer ausgelesen werden können.
Mit dem Methoden-Aufruf Suche.exec() wird der reguläre Ausdruck auf eine Zeichenkette angewandt. Als Parameter wird der Methode der zu durchsuchende Ausdruck übergeben. Die Methode gibt einen Array mit den Treffern zurück, der in der Variable Ergebnis gespeichert wird.
Im Folgenden werden die Informationen aus dem Array mit document.write() ausgegeben. Das erste Element des Arrays (mit dem Index 0) ist der Treffer des Gesamtausdrucks. In den nachfolgenden Array-Elementen (mit dem Index 1 und darüber) sind die Teilstrings gespeichert, auf die die eingeklammerte Ausdrucksteile gepasst haben.
Das Beispiel durchläuft den Array mit einer for-Schleife und gibt auf diese Weise alle Teiltreffer aus. Zudem werden zwei besondere Objekteigenschaften des von exec() zurückgegebenen Arrays demonstriert: index und input. Diese kennt ein gewöhnlicher Array nicht. In der Eigenschaft index ist die Index-Position des Treffers des Gesamtausdrucks gespeichert (beginnend mit 0 für das erste Zeichen der Zeichenkette). In der Eigenschaft input ist die Zeichenkette gespeichert, auf die der Ausdruck mittels exec() angewendet wurde.
Anzeigebeispiel: So sieht's aus
<html><head><title>Test</title>
</head><body>
<script type="text/javascript">
var derSatz = "Auf der Mauer, auf der Lauer sitzt 'ne kleine Wanze.";
var Suche = /auf der (\w*)/gi;
var Ergebnis;
document.write("<ol>");
while (Ergebnis = Suche.exec(derSatz)) {
document.write("<li>" + Ergebnis[1] + "<\/li>");
}
document.write("<\/ol>");
</script>
</body></html>
Das obige Beispiel veranschaulicht das mehrfache Anwenden von exec(), um alle möglichen Treffer eines Ausdrucks in Erfahrung zu bringen. Eine ähnliche Aufgabe ist zwar mit match() lösbar, aber match() erlaubt keinen Zugriff auf die jeweiligen Teiltreffer. Über RegExp.$1 und folgende Eigenschaften können lediglich die Teiltreffer des letzten Vorkommens gelesen werden. exec() hat diese Einschränkung nicht.
Zunächst wird ein regulärer Ausdruck mit dem Zusatz /.../gi definiert. Die Angabe g stellt sicher, dass exec() mehrmals auf einen String angewendet werden kann und dadurch alle Vorkommen gefunden werden. Die Angabe i stellt sicher, dass die Groß- und Kleinschreibung bei der Suche keine Rolle spielt. Der Ausdruck passt auf den festen Text auf der gefolgt von einem Wort beliebiger Länge (\w*).
Damit exec() genau so oft ausgeführt wird, wie weitere Vorkommen gefunden werden, wird eine spezielle while-Schleife benutzt. Als Schleifenbedingung wird nicht wie üblich ein einfacher logischer Ausdruck (z.B. i > 5) notiert, sondern die Wertzuweisung Ergebnis = Suche.exec(derSatz). - Dies ist möglich, da eine Wertzuweisung ebenfalls ein Ausdruck ist, wie z.B. window.alert(Variable = "Wert"); veranschaulicht. - Ihr Ergebnis gleicht dem des rechten Bestandteils Suche.exec(derSatz), also dem exec()-Aufruf. Dies ist entweder einen Array mit den Suchergebnissen, falls ein Vorkommen gefunden wurde, oder null, falls keine weiteren Vorkommen existieren. Als Ergebnis des Ausdrucks an der Stelle while (Ausdruck) { ... } wird entweder true oder false erwartet. Daher wandelt JavaScript das Ergebnis von Suche.exec(derSatz) entsprechend um. Ein Array gilt als true, sodass die Schleife im Erfolgsfalle fortgesetzt wird. Der Wert null gilt als false, sodass die Schleife abgebrochen wird, nachdem das letzte Vorkommen gefunden wurde.
Im Schleifenkörper wird der Array Ergebnis verwendet. Dieser ist bei jedem Schleifendurchlauf neu gefüllt, da vor jedem Durchlauf die Schleifenbedingung ausgeführt wird - in diesem Fall der Aufruf von exec() und das Speichern des Rückgabewerts in der Variable Ergebnis. Über Ergebnis[1] wird schließlich der Treffer des ersten Teilausdrucks ausgegeben.
Wie im Eingangsbeispiel illustriert, können Sie auf die Teiltreffer eines exec()-Aufrufs anstatt über den zurückgegebenen Array auch über RegExp.$1 und folgende Eigenschaften zugreifen. Diese Zugriffsweise wird allerdings seit der JavaScript-Version 1.5 als veraltet eingestuft und ist zumindest im Zusammenhang mit exec() auch praktisch unnötig.
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.
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>
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
|
| SELFHTML/Navigationshilfen JavaScript/DOM Objektreferenz |
|
© 2005 Impressum