Grupper

Använda grupper med kvantifierare

Om du inte använder grupper tillämpas kvantifierare på tecknet eller teckenklassen som föregår dem, vilket framgår av exemplet nedan:

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

Du kan emellertid använda en grupp för att tillämpa en kvantifierare på mer än ett tecken eller en teckenklass.

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

Mer information om kvantifierare finns i Kvantifierare.

Använda grupper med vertikalstrecket (|)

Med grupper kan du definiera teckengrupper för vilka du vill tillämpa vertikalstrecket (|) enligt följande:

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

Använda grupper för att hämta delsträngsmatchningar

När du definierar en vanlig parentetisk grupp i ett mönster kan du referera till den senare i det reguljära uttrycket. Detta kallas en bakåtreferens och grupperna kallas hämtade grupper. I följande reguljära uttryck matchar sekvensen \1 delsträngar som matchade den hämtade parentetiska gruppen:

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

Du kan ange upp till 99 bakåtreferenser i ett reguljärt uttryck genom att skriva \1, \2, ... , \99.

På samma sätt kan du i metoden replace() i strängen String använda $1–$99 för att infoga hämtade grupper i ersättningssträngen:

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

Om du dessutom använder hämtade grupper returnerar metoden exec() i klassen RegExp och metoden match() i klassen String delsträngarna som matchar de hämtade grupperna:

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

Använda icke-hämtade grupper och framåtblickande grupper

En icke-hämtad grupp är en grupp som endast används för gruppering. Den ”samlas” inte in och den matchar inte numrerade bakåtreferenser. Använd (?: och ) för att definiera icke-hämtade grupper enligt följande:

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

Observera till exempel skillnaden mellan att placera (com|org) i en hämtad och icke-hämtad grupp (metoden exec() visar hämtade grupper efter en avslutad matchning):

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

En speciell typ av icke-hämtade grupper är framåtblickande grupper, av vilka det finns två typer: den positivt framåtblickande gruppen och den negativt framåtblickande gruppen.

Använd (?= och ) för att definiera en positiv framåtblickande grupp där ett delmönster i en grupp måste matcha den avsedda positionen. Emellertid kan den delen av strängen som matchar den positiva framåtblickande gruppen också matcha återstående mönster i det reguljära uttrycket. Eftersom (?=e) är en positiv framåtblickande grupp i exemplet nedan, kan tecknet e som den matchar matcha en efterföljande del i det reguljära uttrycket – i detta fall den hämtade gruppen, \w*):

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

Använd (?! och ) för att definiera en negativ framåtblickande grupp som anger att delmönstret i gruppen inte behöver matcha den avsedda positionen. Till exempel:

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

Använda namngivna grupper

En namngiven grupp är en grupp i ett reguljärt uttryck som har en namngiven identifierare. Använd (?P<name> och ) för att definiera den namngivna gruppen. I följande reguljära uttryck finns en namngiven grupp med en identifierare med namnet digits:

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

När du använder metoden exec(), läggs en matchande namngiven grupp till som en egenskap för arrayen 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

Här är visas ett exempel där två namngivna grupper, med identifierarna name och dom, används:

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