Grupos -- Flash CS3

Se puede especificar un grupo en una expresión regular utilizando paréntesis, de la manera siguiente:

En las secciones siguientes se proporcionan detalles sobre estos usos de los grupos.

Subtemas

Utilización 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*/ ;
// detecta el carácter a seguido de
// cero o más instancias del carácter b

pattern = /a\d+/; 
// detecta el carácter a seguido de 
// uno o más dígitos

pattern = /a[123]{1,3}/;
// detecta el carácter a seguido de 
// entre una y tres instancias de 1, 2 ó 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)*/;
// detecta cero o más instancias del carácter a 
// seguido del carácter b, como en ababab

pattern = /(a\d)+/;
// detecta una o más instancias del carácter a seguido de 
// un dígito, como en a1a5a8a3

pattern = /(spam ){1,3}/; 
// detecta entre 1 y 3 instancias de la palabra spam seguidas de un espacio

Utilización 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/;
// detecta cat o dog

pattern = /ca(t|d)og/;
// detecta catog o cadog

Utilización 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/;
// detecta lo siguiente: 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."));
// salida: 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@test.com,bob,example,com

Utilización de grupos que no capturan y grupos de búsqueda hacia delante

Un grupo que no captura es un grupo que sólo 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@test.com,bob,example,com
  
//sin captura:
var pattern:RegExp = /(\w+)@(\w+).(?:com|org)/;
var str:String = "bob@example.com";
trace(pattern.exec(str));
  // bob@test.com,bob,example

Un tipo de especial de grupo que no captura es el grupo de búsqueda hacia delante, del que 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

Utilización 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 de la 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

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); // ejemplo