Groepen

Groepen gebruiken met kwantoren

Als u geen groep gebruikt, heeft een kwantor betrekking op het teken of de tekenklasse die hieraan voorafgaat, zoals uit het onderstaande blijkt:

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

U kunt echter een groep gebruiken om een kwantor toe te voegen aan meer dan een teken of tekenklasse:

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

Zie Kwantoren voor meer informatie over kwantoren.

Groepen gebruiken met de verticale balk ( | )

U kunt groepen gebruiken om de groep tekens te definiëren waarop u een verticale balk ( | ) wilt toepassen:

var pattern:RegExp = /cat|dog/; 
// matches cat or dog 
 
pattern = /ca(t|d)og/; 
// matches catog or cadog

Groepen gebruiken om overeenkomstige subreeksen vast te leggen

Wanneer u een standaardgroep tussen haakjes in een patroon vastlegt, kunt u er later in de reguliere expressie naar verwijzen. Dit wordt terugverwijzing genoemd, en deze soort groepen worden vastgelegde groepen genoemd In de volgende reguliere expressie bijvoorbeeld komt de reeks \1 overeen met een willekeurige subreeks die met de vastgelegde groep tussen haakjes overeenkomt:

var pattern:RegExp = /(\d+)-by-\1/; 
// matches the following: 48-by-48

U kunt maximaal 99 van deze terugverwijzingen vastleggen in een reguliere expressie door \1 , \2 , ..., \99 te typen.

Op dezelfde manier kunt u in de methode replace() van de klasse String $1$99 – gebruiken om overeenkomende vastgelegde groepsubreeksen in de vervangende tekenreeks in te voegen:

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

Als u vastgelegde groepen gebruikt, retourneren de methode exec() van de klasse RegExp en de methode match() van de klasse String subreeksen die overeenkomen met de vastgelegde groepen:

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

Gebruiken van niet vastgelegde groepen en lookahead-groepen

Een niet vastgelegde groep is een groep die alleen wordt gebruikt om mee te groeperen; deze wordt niet gebruikt om mee te 'verzamelen' en bevat geen overeenkomsten met genummerde terugverwijzingen. Gebruik (?: en ) om niet vastgelegde groepen als volgt te definiëren:

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

Houd bijvoorbeeld rekening met het verschil wanneer (com|org) in een vastgelegde versus een niet vastgelegde groep wordt geplaatst (de methode exec() vormt een opsomming van vastgelegde groepen na volledige overeenkomst):

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

Een bijzonder soort niet vastgelegde groep is de groep lookahead waarvan twee types bestaan: de positieve lookahead-groep en de negatieve lookahead-groep.

Gebruik (?= en ) om een positieve lookahead-groep te definiëren, waarmee wordt aangegeven dat het subpatroon in de groep moet overeenkomen met de positie. Het gedeelte van de tekenreeks dat echter overeenkomt met de positieve lookahead-groep, kan overeenkomen met overige patronen binnen de reguliere expressie. Aangezien (?=e) bijvoorbeeld een positieve lookahead-groep binnen de volgende code is, kan het teken e waarmee het overeenkomt in overeenstemming worden gebracht met een volgend deel van de reguliere expressie, in dit geval de vastgelegde groep, \w*) :

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

Gebruik (?! en ) om een negatieve lookahead-groep te definiëren die aangeeft dat het subpatroon in de groep niet moet overeenkomen met de positie. Bijvoorbeeld:

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

Gebruiken van benoemde groepen

Een benoemde groep is een soort groep in een reguliere expressie waaraan een benoemde id is toegewezen. Gebruik (?P<name> en ) om de benoemde groep te definiëren. De volgende reguliere expressie bevat bijvoorbeeld een groep met een benoemde id digits :

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

Wanneer u de methode exec() gebruikt, wordt een overeenkomende benoemde groep toegevoegd als eigenschap van de array result :

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

Hier volgt nog een voorbeeld, waarbij gebruik wordt gemaakt van twee benoemde groepen, met de id's name en 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