|
|
|
Die Schreibweise von regulären Ausdrücken in JavaScript lehnt sich
sehr eng an die Definition in
Perl
an.
Zum Beispiel
Zur Beschreibung des Suchmusters stehen eine Reihe von Zeichen mit besonderer
Bedeutung zur Verfügung:
Beschreibung
Quelltext
<head>
<script language="JavaScript">
<!--
function testre() {
if(window.RegExp == null) {
alert("Ihr Browser unterstuetzt keine regulaeren Ausdruecke !");
return false;
} else {
win=window.open("","regexp", "resizeable=1,scrollbars=1,width=400,height=400");
return true;
}
}
//-->
</script>
</head>
<body>
<form action="regexp.htm" method="get" onSubmit="return testre();" target="regexp">
Satz :
<input type="text" name="satz" size=64
value="Papa packt 10 Grappa in das Papppaket"><br>
Ausdruck :
<input type="text" name="expr" size=8 value="ap+a" >
global match <input type=checkbox name="glob" checked>
ignore case <input type=checkbox name="igno"><br>
<input type="submit" value="Auswerten">
</form>
</body>
regexp.htm
<script language="JavaScript">
<!--
window.focus();
input=window.location.search;
input=input.substring(1, input.length);
input=input.split("&");
if (input.length < 2) {
alert("unvollstaendige Eingabeparameter");
history.back();
}
satz=input[0].split("=");
if(satz.length < 2 || satz[0] != "satz") {
alert("fehlerhafte Eingabeparameter satz");
history.back();
}
satz=unescape(satz[1].replace(/\+/g, " "));
document.write("Eingabe-Satz:<br><b>"+satz.fontsize("+1")+"</b></p>");
worte=satz.split(/\s/);
document.write("Der Satz besteht aus "+worte.length+
" Worten, und zwar:<br>"+worte+"<p>");
document.write("Das erste Wort ist "+satz.match(/^\w+/)+"<br>");
document.write("Das letzte Wort ist "+satz.match(/\S+$/)+"<br>");
document.write("Die erste Zahl in dem Satz ist "+satz.match(/\d+/)+"<p>");
document.write("Das ersetzen von <b>pa</b> durch <b>ma</b> ergibt den "+
"neuen Satz<br>"+satz.replace(/pa/gi, "ma")+"<p>");
expr=input[1].split("=");
if(expr.length > 1 && expr[0] == "expr") {
expr=unescape(expr[1].replace(/\+/g, " "));
para="";
for(ii=2; ii<input.length; ii++) {
if(input[ii].substring(0,4) == "glob") {
para=para+"g";
} else if(input[ii].substring(0,4) == "igno") {
para=para+"i";
}
}
expr=new RegExp(expr, para);
resu=satz.match(expr);
document.write("Die Suche nach dem Ausdruck <b>"+expr+"</b> liefert ");
if(resu == null) {
document.write("keine Treffer<br>");
} else {
document.write(resu.length+" Treffer, und zwar:<br>");
document.write(resu+"<br>");
}
}
//-->
</script>
Erläuterung
Referenz
[regular Expressions]
[RegExp-Objekt]
[string-Objekt]
reguläre Ausdrücke (regular Expressions)
Reguläre Ausdrücke sind Suchmuster, mit denen vorgegebene
Zeichenkombinationen in einer Zeichenkette gesucht werden können.
Sie werden eingesetzt in Zusammenhang mit den Methoden exec und test
des regular expression-Objektes sowie den Methoden match,
replace, search und split des string-Objektes.
Der Ausdruck besteht aus der Beschreibung des Suchmusters zwischen zwei
Schrägstrichen / und optional daran angehängt die Schalter
i für ignore case (nicht zwischen Groß- und
Kleinschreibung unterscheiden) und g für global match
(alle Stellen finden, nicht nur die erste).
/pa/ findet das hintere pa von Papa
/pa/i findet das vordere Pa von Papa
/pa/gi findet das Pa und das pa von Papa
| \ | Umschalten zwischen Zeichen mit Sonderbedeutung
und eigentlicher Bedeutung z.B. hat der Stern * eine besondere Bedeutung (s.u.). Wenn aber ausdrücklich nach einem Stern gesucht werden soll, dann muß die Sonderbedeutung abgeschaltet werden: /\*/ . |
| ^ | Zeilenanfang /^Pa/ findet Pa in Papa und Mama aber nicht in Mama und Papa |
| $ | Zeilenende /ma$/ findet ma in Papa und Mama aber nicht in Mama und Papa |
| . | beliebiges Zeichen /u.d/ findet das und in Papa und Mama /a.+a/ findet das apa in Papa und das appa in Grappa |
| | | ODER-Verknüpfung /pa|ma/ findet sowohl das pa als auch das ma in Papa und Mama |
| () | Merken der gefundenen Zeichen /(u.d)/ findet das und in Papa und Mama und merkt es sich. Auf die gemerkten Elemente kann entweder über das Ergebnis-Array oder über die Eigenschaften $1 bis $9 des RegExp-Objektes zugegriffen werden (siehe auch das Beispiel weiter unten). |
| [] | Ein Zeichen aus einer Auswahlliste /[abcdef]/ findet das a von Papa. Es kann auch abgekürzt geschrieben werden: /[a-f]/ oder /[a-fA-F]/ wenn auch Großbuchstaben gesucht werden sollen. |
| [^] | Ein Zeichen, das nicht in der Auswahlliste steht /[^abcdef]/ findet das P von Papa. |
| Anzahl Wiederholungen | |
|---|---|
| * | 0 mal oder öfter /ap*a/ findet das apa von Papa aber auch das aa von Waage |
| + | 1 mal oder öfter /ap+a/ findet das apa von Papa aber auch das appa von Grappa aber nicht das aa von Waage |
| ? | 0 mal oder 1 mal /ap?a/ findet das apa von Papa und auch das aa von Waage aber nicht das appa von Grappa |
| {n} | genau n mal |
| {n,} | n mal oder öfter |
| {n,m} | mindestens n und höchstens m mal |
| besondere Zeichen | |
| \b | Wortgrenze /a\b/ findet das hintere a von Papa |
| \B | Nicht-Wortgrenze /a\B/ findet das vordere a von Papa |
| \d | Ziffer (entspricht [0-9]) /\d/ findet 1 in die 10 Gebote, /\d+/ findet 10 in die 10 Gebote |
| \D | Nicht-Ziffer (entspricht [^0-9]) |
| \s | "Whitespace Character" (Leerzeichen, Tabulator, Zeilenvorschub, Wagenrücklauf) |
| \S | Nicht-"Whitespace Character" |
| \w | "Word Character" (Buchstabe, Ziffer oder Unterstrich) |
| \W | Nicht-"Wort Character" |
| Kontroll-Zeichen | |
| \cX | Control-X |
| \f | Seitenvorschub |
| \n | Zeilenvorschub |
| \r | Wagenrücklauf |
| \t | Tabulator |
| \v | vertikaler Tabulator |
| \oxx | ASCII-Code in oktaler Darstellung |
| \xxx | ASCII-Code in hexadezimaler Darstellung |
Normalerweise können reguläre Ausdrücke direkt
eingegeben werden ("literal notation"). Es kann aber auch ausdrücklich
eine neue Instanz des RegExp-Objektes erzeugt werden. So sind die
beiden folgenden Anweisungen gleichwertig :
myRe = /abc/i;
myRe = new RegExp("abc", "i");
Bitte beachte Sie, daß im ersten Fall der Ausdruck durch
Schrägstriche / umschlossen wird, im zweiten Fall durch
Gänsefüßchen " (die Eingabevarianble also ein
string-Objekt ist).
Die letztere Form ist nur dann zwingend erforderlich, wenn der Ausdruck erst zur Laufzeit des Scripts berechnet oder z.B. aus einer Formulareingabe entnommen wird.
Ein so entstandenes regular Expressions-Objekt hat folgende Eigenschaften:
| source | das eigentliche Suchmuster |
| global | "global match" gesetzt ? (/g) |
| ignoreCase | "ignore case" gesetzt ? (/i) |
| lastIndex | Index, bei dem eine erneute Suche weitermachen müßte |
Außerdem verfügt er über folgende Methoden:
| exec | Ausführen einer Suche; liefert als Ergebnis ein Array, das die gefundene(n) Zeichenkette(n) enthält bzw. das null-Objekt, wenn es keinen Treffer gegeben hat. |
| test | prüft lediglich, ob es (mindestens) einen Treffer gibt, liefert als Ergebnis true oder false |
| compile(expr [,para]) |
erneutes Übersetzen des Ausdrucks, z.B. re.compile("\d+", "g"); |
| langer Name | Kurzname (vgl. Perl) | Beschreibung |
| input | $_ |
Eingabestring (vorbelegt, wenn ein Event-Handler von einem Formularelement TEXT, TEXTAREA oder SELECT gerufen wird: enthält dann den Wert des rufenden Formularelementes; oder wenn ein Event-Handler von einem Link gerufen wird: enthält dann den Klartext zwischen <a> und </a>) |
| multiline | $* | wird über Zeilenumbruch hinaus gesucht ? |
lastMatch  | $& | die zuletzt gefundenen Zeichen |
| lastParen | $+ | die zuletzt gemerkten Zeichen |
| leftContext | $\Q | Unterkette links von den zuletzt gefundenen Zeichen |
| rightContext | $' | Unterkette rechts von den zuletzt gefundenen Zeichen |
| $1 ... $9 | 1. bis 9. gemerkte Zeichenkette (runde Klammer im Ausdruck) | |
string-Objekt
Das string-Objekt besitzt folgende neue Methoden in
Version 1.2
| Methode | Ergebnis | Beschreibung |
| match(expr) | string-Array | Suchen (aller) passender Stellen |
| search(expr) | index oder -1 | prüft lediglich, ob es (mindestens) einen Treffer gibt |
| replace(expr, neu) | neuer string | Ersetzt (alle) gefundenen Treffer durch die Zeichenkette neu. |
| split(expr) | string-Array | Teilt einen string an durch den regulären Ausdruck beschriebenen Stellen in einzelne Unter-strings auf |
| Auf der nächsten Seite ... |
|
