Grupos

Uso de grupos con cuantificadores

Si no se utiliza un grupo, un cuantificador se aplica al carácter o la clase de caracteres que lo precede, como se indica a continuación:

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

No obstante, se puede utilizar un grupo para aplicar un cuantificador a más de un carácter o clase 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 más información sobre los cuantificadores, consulte Cuantificadores .

Uso de los grupos con el carácter alternador (|)

Se pueden utilizar grupos para definir el grupo de caracteres al que se desea aplicar un carácter alternador ( | ), de la manera siguiente:

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

Uso de grupos para capturar coincidencias de subcadenas

Si se define un grupo delimitado por paréntesis estándar en un patrón, se puede hacer referencia al mismo en una parte posterior de la expresión regular. Esto se denomina referencia a un elemento detectado previamente (backreference) y estos tipos de grupos se denominan grupos de captura . Por ejemplo, en la siguiente expresión regular, la secuencia \1 detectará la subcadena que se haya detectado en el primer grupo de captura delimitado con paréntesis:

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

Se pueden especificar hasta 99 de estas referencias a elementos detectados previamente escribiendo \1 , \2 , ..., \99 .

De forma similar, en el método replace() de la clase String, se puede utilizar $1$99 – para insertar subcadenas coincidentes detectadas con un grupo de captura en la cadena de sustitución:

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

Además, si se utilizan grupos de captura, el método exec() de la clase RegExp y el método match() de la clase String devuelven subcadenas que detectan los grupos de captura:

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 que no capturan y grupos de búsqueda hacia delante

Un grupo que no captura es un grupo que solo se utiliza para agrupar; no se "almacena" ni proporciona referencias numeradas de elementos detectados previamente. Para definir grupos que no capturan se utiliza (?: y ) , de la manera siguiente:

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

Por ejemplo, véase la diferencia entre colocar (com|org) en grupo de captura y en un grupo que no captura (el método exec() muestra los grupos de captura después de la coincidencia completa):

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

Un tipo especial de grupo que no captura es el grupo de búsqueda hacia delante , del cual hay dos tipos: el grupo de búsqueda positiva hacia delante y el grupo de búsqueda negativa hacia delante .

Para definir un grupo de búsqueda positiva hacia delante, que especifica que el subpatrón del grupo debe coincidir en la posición, se utiliza (?= y ) . No obstante, la parte de la cadena que coincide con el grupo de búsqueda positiva hacia delante puede coincidir con los demás patrones de la expresión regular. Por ejemplo, como (?=e) es un grupo de búsqueda positiva hacia delante en el código siguiente, el carácter e que detecta puede ser detectado por una parte posterior de la expresión regular, en este caso, el 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

Para definir un grupo de búsqueda negativa hacia delante, que especifica que el subpatrón del grupo no debe coincidir en la posición, se utiliza (?! y ) . Por ejemplo:

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 con nombre

Un grupo con nombre es un tipo de grupo en una expresión regular al que se le da un identificador designado. Para definir el grupo con nombre se utiliza (?P<nombre> y ) Por ejemplo, la siguiente expresión regular incluye un grupo con nombre con el identificador denominado digits :

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

Cuando se utiliza el método exec() , se añade un grupo con nombre coincidente como una propiedad del conjunto 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

Otro ejemplo, en el que se utilizan dos grupos con nombre, con los identificadores name y 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