Gruppen -- Flash CS3

Sie können eine Gruppe in einem regulären Ausdruck durch Klammern angeben, wie im Folgenden dargestellt:

Eine Gruppe ist ein Teilbereich eines Musters. Gruppen können für Folgendes verwendet werden:

In den folgenden Abschnitten finden Sie ausführliche Informationen zur Verwendung von Gruppen.

Unterthemen

Verwenden von Gruppen mit Quantifizierern

Wenn Sie keine Gruppe verwenden, werden Quantifizierer wie folgt auf Zeichen oder Zeichenklassen angewendet, die vor dem Quantifizierer stehen:

var pattern:RegExp = /ab*/ ;
// Entspricht dem Zeichen a, gefolgt von
// keinem, einem oder mehreren Vorkommen des Zeichens b.

pattern = /a\d+/; 
// Entspricht dem Zeichen a, gefolgt von 
// mindestens einer Ziffer.

pattern = /a[123]{1,3}/;
// Entspricht dem Zeichen a, gefolgt von 
// ein bis drei Vorkommen der Ziffern 1, 2 oder 3.

Sie können jedoch eine Gruppe verwenden, um einen Quantifizierer auf mehrere Zeichen oder Zeichenklassen anzuwenden:

var pattern:RegExp = /(ab)*/;
// Entspricht null oder mindestens einem Vorkommen des Zeichens a 
// gefolgt vom Buchstaben b, z. B. ababab.

pattern = /(a\d)+/;
// Entspricht mindestens einem Vorkommen des Zeichens a, gefolgt von 
// einer Zahl, z. B. a1a5a8a3.

pattern = /(spam ){1,3}/; 
// Entspricht ein bis drei Vorkommen des Wortes spam, gefolgt von einem Leerzeichen.

Verwenden von Gruppen mit dem Auswahlzeichen (|)

Mithilfe von Gruppen können Sie eine Zeichengruppe definieren, auf die das Auswahlzeichen (|) angewendet werden soll, wie im Folgenden dargestellt:

var pattern:RegExp = /cat|dog/;
// Entspricht cat oder dog.

pattern = /ca(t|d)og/;
// Entspricht catog oder cadog.

Verwenden von Gruppen zum Zwischenspeichern übereinstimmender Teilstrings

Wenn Sie in einem Muster eine Standardgruppe in Klammern definieren, können Sie später im regulären Ausdruck auf die Gruppe verweisen. Dies wird als Rückverweis bezeichnet. Die entsprechenden Gruppen stellen zwischengespeicherte Gruppen dar. Die Sequenz \1 im folgenden regulären Ausdruck entspricht beispielsweise allen Teilstrings, die der in Klammern eingeschlossenen zwischengespeicherten Gruppe entsprechen:

var pattern:RegExp = /(\d+)-by-\1/;
// entspricht Folgendem: 48-by-48

Sie können bis zu 99 dieser Rückverweise in einem regulären Ausdruck angeben, indem Sie \1, \2, ... , \99 eingeben.

Ebenso können Sie bei der replace()-Methode der String-Klasse $1-$99 verwenden, um die mit der zwischengespeicherten Gruppe übereinstimmenden Teilstrings im Ersetzungsstring einzufügen:

var pattern:RegExp = /Hi, (\w+)\./;
var str:String = "Hi, Bob.";
trace(str.replace(pattern, "$1, hello."));
// Ausgabe: Bob, hello.

Bei Verwendung von zwischengespeicherten Gruppen geben die exec()-Methode der RegExp-Klasse und die match()-Methode der String-Klasse Teilstrings zurück, die diesen Gruppen entsprechen:

var pattern:RegExp = /(\w+)@(\w+).(\w+)/;
var str:String = "bob@example.com";
trace(pattern.exec(str));
  // bob@test.com,bob,example,com

Verwenden von nicht zwischengespeicherten Gruppen und Vorschaugruppen

Eine nicht zwischengespeicherte Gruppe wird nur zum Gruppieren verwendet. Sie wird nicht zwischengespeichert und kann deshalb nicht mit nummerierten Rückverweisen referenziert werden. Mithilfe von (?: und ) können Sie nicht zwischengespeicherte Gruppen wie folgt definieren:

var pattern = /(?:com|org|net);

Beachten Sie beispielsweise den Unterschied zwischen dem Einfügen von (com|org) in einer zwischengespeicherten und in einer nicht zwischengespeicherten Gruppe (mit der exec()-Methode werden zwischengespeicherte Gruppen nach der abgeschlossenen Suche aufgelistet):

var pattern:RegExp = /(\w+)@(\w+).(com|org)/;
var str:String = "bob@example.com";
trace(pattern.exec(str));
  // bob@test.com,bob,example,com
  
// nicht zwischengespeicherte Gruppe:
var pattern:RegExp = /(\w+)@(\w+).(?:com|org)/;
var str:String = "bob@example.com";
trace(pattern.exec(str));
  // bob@test.com,bob,example

Bei einer Vorschaugruppe (Lookahead) handelt es sich um einen speziellen Typ einer nicht zwischengespeicherten Gruppe. Es gibt zwei Typen: die positive Vorschaugruppe und die negative Vorschaugruppe.

Mithilfe von (?= und ) können Sie eine positive Vorschaugruppe definieren, die nur das Teilmuster ab der übereinstimmenden Position enthält. Der Teil des Strings, der der positiven Vorschaugruppe entspricht, kann jedoch auch noch mit weiteren Mustern im regulären Ausdruck übereinstimmen. Da (?=e) im folgenden Code eine positive Vorschaugruppe ist, kann das mit ihr übereinstimmende Zeichen e auch einem darauf folgenden Teil im regulären Ausdruck entsprechen, in diesem Fall der zwischengespeicherten Gruppe (\w*):

var pattern:RegExp = /sh(?=e)(\w*)/i;
var str:String = "Shelly sells seashells by the seashore";
trace(pattern.exec(str));
// Shelly,elly

Mithilfe von (?! und ) können Sie eine negative Vorschaugruppe definieren, mit der angegeben wird, dass das Teilmuster in der Gruppe nicht an der entsprechenden Position übereinstimmen darf. Beispiel:

var pattern:RegExp = /sh(?!e)(\w*)/i;
var str:String = "She sells seashells by the seashore";
trace(pattern.exec(str));
// shore,ore

Verwenden von benannten Gruppen

Eine benannte Gruppe ist ein Gruppentyp in einem regulären Ausdruck, für die ein benannter Bezeichner angegeben ist. Mithilfe von (?P<Name> und ) können Sie eine benannte Gruppe definieren. Der folgende reguläre Ausdruck enthält beispielsweise eine benannte Gruppe mit dem Bezeichner digits:

var pattern = /[a-z]+(?P<digits>\d+)[a-z]+/;

Bei Verwendung der exec()-Methode wird eine übereinstimmende benannte Gruppe als Eigenschaft des result-Arrays hinzugefügt:

var myPattern:RegExp = /([a-z]+)(?P<digits>\d+)[a-z]+/; 
var str:String = "a123bcd";
var result:Array = myPattern.exec(str);
trace(result.digits); // 123

Es folgt ein weiteres Beispiel mit zwei benannten Gruppen mit den Bezeichnern name und dom:

var emailPattern:RegExp = 
    /(?P<name>(\w|[_.\-])+)@(?P<dom>((\w|-)+))+\.\w{2,4}+/; 
var address:String = "bob@example.com";
var result:Array = emailPattern.exec(address);
trace(result.name); // bob
trace(result.dom); // example