Grupy

/class-(\d*)/

Korzystanie z grup z kwantyfikatorami

Jeśli programista nie korzysta z grup, kwantyfikator zostanie zastosowany do poprzedzającego go znaku lub klasy znaku, co ilustruje poniższy przykład:

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

Grupy można jednak użyć, aby zastosować kwantyfikator do więcej niż jednego znaku lub klasy znaku:

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

Więcej informacji na temat kwantyfikatorów zawiera sekcja Kwantyfikatory .

Korzystanie z grup ze znakiem alternatora (|)

Grup można używać do definiowania grup znaków, do których ma zostać zastosowany znak alternatora ( | ), co ilustruje poniższy przykład:

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

Korzystanie z grup w celu przechwytywania dopasowań podciągów

Po zdefiniowaniu we wzorcu standardowej grupy w nawiasach okrągłych można się później do niej odwołać w wyrażeniu regularnym. Czynność ta nazywana jest odwołaniem wstecznym , a tego rodzaju grupy grupami przechwyconymi . Na przykład: w poniższym wyrażeniu regularnym sekwencja \1 dopasowuje wszystko, co podciąg dopasował w grupie przechwyconej ujętej w nawias:

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

W wyrażeniu regularnym można określić do 99 odwołań wstecznych przez wpisanie \1 , \2 , ... , \99 .

Podobnie w metodzie replace() klasy String można użyć $1$99 – aby wstawić przechwycone dopasowania podciągów grupy w ciągu zastępowania:

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

Również metoda exec() klasy RegExp oraz metoda match() klasy String zwracają podciągi zgodne z grupami przechwyconymi, jeśli programista korzysta z grup przechwyconych:

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

Korzystanie z grup nieprzechwyconych i grup uprzedzonych

Grupa nieprzechwycona jest grupą, która używana jest jedynie do grupowania; nie jest „gromadzona” i nie dopasowuje wielu odwołań wstecznych. Należy użyć (?: i ) , aby zdefiniować grupy nieprzechwycona, co ilustruje poniższy przykład:

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

Na przykład: należy zauważyć różnicę między wstawianiem (com|org) w przechwyconej i nieprzechwyconej grupie (metoda exec() wyświetla grupy przechwycone po zakończeniu dopasowywania):

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

Specjalnym typem grupy nieprzechwyconej jest grupa uprzedzona , której istnieją dwa typy: dodatnia grupa uprzedzona i ujemna grupa uprzedzona .

Należy użyć (?= i ) , aby zdefiniować dodatnią grupę uprzedzoną, która wskazuje, że podciąg wzorca w grupie musi być dopasowany w tym położeniu. Jednak fragment ciągu dopasowanego do dodatniej grupy uprzedzonej może dopasować pozostałe wzorce wyrażenia regularnego. Przykład: ponieważ (?=e) jest dodatnią grupą uprzedzoną w poniższym kodzie, znak e , do której została dopasowana, może zostać dopasowany przez kolejną część wyrażenia regularnego — w tym przypadku grupę przechwyconą \w*) :

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

Należy użyć (?! i ) , aby zdefiniować ujemną grupę uprzedzoną, która wskazuje, że podciąg wzorca w grupie nie może być dopasowany w tym położeniu. Na przykład:

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

Korzystanie z grup nazwanych

Grupa nazwana jest typem grupy w wyrażeniu regularnym, której nadany został identyfikator nazwany. Należy użyć (?P<name> i ) , aby zdefiniować grupę nazwaną. Na przykład: poniższe wyrażenie regularne zawiera grupę nazwaną z identyfikatorem o nazwie digits :

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

Podczas korzystania z metody exec() dopasowana grupa nazwana dodawana jest jako właściwość tablicy 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

Kolejny przykład, w którym używane są dwie grupy nazwane z identyfikatorami name i 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