Grupos

Uso de grupos com quantificadores

Se você não usar um grupo, um quantificador se aplicará ao caractere ou classe de caracteres que o precede, como mostrado a seguir:

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

Entretanto, você pode usar um grupo para aplicar um quantificador a mais de um caractere ou classe de caracteres:

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

Para obter mais informações sobre quantificadores, consulte Quantificadores.

Uso de grupos com o caractere alternador (|)

Você pode usar grupos para definir o grupo de caracteres aos quais deseja aplicar um caractere alternador (|), como se segue:

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

Uso de grupos para capturar correspondências de substrings

Quando terminar de definir um grupo entre parênteses padrão, poderá se referir a ele posteriormente na expressão regular. Isso é conhecido como referência anterior, e essas classificações de grupos são conhecidas como capturas de grupos. Por exemplo, na expressão regular a seguir, a seqüência \1 corresponde a qualquer substring que correspondeu à captura do grupo entre parênteses:

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

Você pode especificar até 99 dessas referências anteriores em uma expressão regular digitando \1, \2, ... , \99.

De modo semelhante, no método replace() da classe String, você pode usar $1$99– para inserir correspondência de substring de grupos capturados na string de substituição:

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

Além disso, se você usar a captura de grupo, o método exec() da classe RegExp e o método match() da classe String retornarão substrings que correspondem à captura de grupos:

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

Uso de grupos de não captura e grupos lookahead

Um grupo de não captura é aquele que é usado para agrupamento apenas; ele não é "coletado" e não corresponde a referências anteriores numeradas. Use (?: e ) para definir grupos de não captura, como se segue:

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

Por exemplo, observe a diferença entre colocar (com|org) em uma captura versus um grupo de não captura (o método exec() lista os grupos de captura depois da conclusão da correspondência):

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

Um tipo especial de grupo de não captura é o grupo lookahead, composto por dois tipos: o grupo lookahead positivo e o grupo lookahead negativo.

Use (?= e ) para definir um grupo lookahead positivo, que especifica que o subpadrão no grupo deve corresponder à posição. Entretanto, a porção da string que corresponde ao grupo lookahead positivo pode corresponder aos padrões restantes na expressão regular. Por exemplo, como (?=e) é um grupo lookahead positivo no código a seguir, o caractere e ao qual ele corresponde pode ser correspondido por uma parte subseqüente da expressão regular — nesse caso, o grupo de captura, \w*):

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

Use (?! e ) para definir um grupo lookahead negativo, que especifica que o subpadrão no grupo não deve corresponder à posição. Por exemplo:

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

Uso de grupos nomeados

Um grupo nomeado é um tipo de grupo em uma expressão regular que tem um identificador nomeado. Use (?P<name> e ) para definir um grupo nomeado. Por exemplo, as expressões regulares a seguir incluem um grupo nomeado com os dígitos nomeados do identificador:

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

Quando você use o método exec(), uma correspondência de grupo nomeado é adicionada como uma propriedade da matriz 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

Aqui está outro exemplo, que usa dois grupos nomeados, com os identificadores name e 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