Grupper

Flash Player 9 och senare, Adobe AIR 1.0 och senare

Med parenteser kan du ange en grupp i ett reguljärt uttryck, vilket visas i följande exempel:

/class-(\d*)/

En grupp är ett delavsnitt i ett mönster. Du använder grupper för bl.a. följande:

  • Tillämpa en kvantifierare på mer än ett tecken.

  • Urskilja delmönster för växlingar (med hjälp av tecknet | ).

  • Hämta delsträngsmatchningar (t.ex. med hjälp av \1 i ett reguljärt uttryck för att matcha en tidigare matchad grupp eller genom att använda $1 på samma sätt i metoden replace() i klassen String).

I följande avsnitt finns mer information om hur du använder dessa 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
Obs! Namngivna grupper ingår inte i språkspecifikationen ECMAScript. De är extrafunktioner i ActionScript 3.0.