Gruppen

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*/ ; 
// matches the character a followed by 
// zero or more occurrences of the character b 
 
pattern = /a\d+/;  
// matches the character a followed by  
// one or more digits 
 
pattern = /a[123]{1,3}/; 
// matches the character a followed by  
// one to three occurrences of either 1, 2, or 3

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

var pattern:RegExp = /(ab)*/; 
// matches zero or more occurrences of the character a  
// followed by the character b, such as ababab 
 
pattern = /(a\d)+/; 
// matches one or more occurrences of the character a followed by  
// a digit, such as a1a5a8a3 
 
pattern = /(spam ){1,3}/;  
// matches 1 to 3 occurrences of the word spam followed by a space

Weitere Informationen zu Quantifizierern finden Sie unter Quantifizierer .

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/; 
// matches cat or dog 
 
pattern = /ca(t|d)og/; 
// matches catog or 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/; 
// matches the following: 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.")); 
  // output: 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@example.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@example.com,bob,example,com 
 
//noncapturing: 
var pattern:RegExp = /(\w+)@(\w+).(?:com|org)/; 
var str:String = "bob@example.com"; 
trace(pattern.exec(str)); 
  // bob@example.com,bob,example

Ein spezieller Typ der zwischengespeicherten Gruppe ist die Vorschaugruppe , von der es zwei Typen gibt: 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. Zum 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