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.