Gruppi -- Flash CS3

Per specificare un gruppo all'interno di un'espressione regolare si possono usare le parentesi, come nell'esempio seguente:

Sezioni

Uso di gruppi e di quantificatori

Se non sono stati definiti dei gruppi, il quantificatore si riferisce al carattere o alla classe di caratteri che lo precede, come illustra l'esempio seguente:

var pattern:RegExp = /ab*/ ;
// corrisponde al carattere a seguito da
// zero o più occorrenze del carattere b

pattern = /a\d+/; 
// corrisponde al carattere a seguito da 
// una o più cifre

pattern = /a[123]{1,3}/;
// corrisponde al carattere a seguito da 
// da una a tre occorrenze di 1, 2 o 3

Tuttavia, definendo un gruppo è possibile applicare un quantificatore a più di un carattere o a più di una classe di caratteri:

var pattern:RegExp = /(ab)*/;
// corrisponde a zero o a più occorrenze del carattere a 
// seguito dal carattere b, come in ababab

pattern = /(a\d)+/;
// corrisponde a una o a più occorrenze del carattere a seguito da 
// una cifra, come in a1a5a8a3

pattern = /(spam ){1,3}/; 
// corrisponde a 1, 2 o 3 occorrenze della parola spam seguita da uno spazio

Uso dei gruppi con il carattere di alternanza (|)

I gruppi consentono di definire una serie di caratteri a cui applicare il carattere di alternanza (|), nel modo seguente:

var pattern:RegExp = /cat|dog/;
// corrisponde a cat o a dog

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

Uso dei gruppi per rilevare corrispondenze a sottostringhe

Se all'interno di un modello si definisce un gruppo parentetico standard, è possibile aggiungere dei riferimenti al gruppo in un punto successivo dell'espressione regolare. Questo tipo riferimenti sono definiti a posteriori e questo tipo di gruppi sono conosciuti come gruppi di cattura. Ad esempio, nell'espressione regolare seguente, la sequenza \1 corrisponde alla sottostringa individuati dal gruppo di cattura parentetico:

var pattern:RegExp = /(\d+)-by-\1/;
// corrisponde a: 48-by-48

All'interno di un'espressione regolare, si possono specificare fino a 99 riferimenti a posteriori digitando \1, \2, ... , \99.

Analogamente, nel metodo replace() della classe String, si può usare $1-$99 per inserire nella stringa di sostituzione corrispondenze a sottostringhe dei gruppi catturati:

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

Inoltre, quando si usano gruppi di cattura, il metodo exec() della classe RegExp class e il metodo match() della classe String restituiscono sottostringhe che corrispondono ai gruppi di cattura:

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

Uso dei gruppi di non cattura e dei gruppi lookahead

Un gruppo di non cattura è un semplice costrutto di raggruppamento che non viene raccolto e fa riferimento a corrispondenze precedenti. Usare (?: e ) per definire i gruppi di non cattura come descritto di seguito:

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

Ad esempio, si noti la differenza che esiste tra inserire (com|org) in un gruppo di cattura e inserirlo in un gruppo di non cattura (il metodo exec() elenca i gruppi di cattura dopo una corrispondenza completa):

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

Un tipo speciale di gruppo di non cattura è il gruppo lookahead che, a sua volta, si declina in due tipi: gruppo lookahead positivo e gruppo lookahead negativo.

Per definire un gruppo lookahead positivo, usare (?= e ), che specifica che il sottomodello del gruppo deve corrispondere alla posizione. Tuttavia, la porzione di stringa che corrisponde al gruppo lookahead positivo può corrispondere agli altri modelli dell'espressione regolare. Ad esempio, dal momento che nel frammento di codice seguente (?=e) è un gruppo lookahead positivo, il carattere e individuato può essere individuato anche da porzioni successive dell'espressione regolare, in questo caso dal gruppo di cattura \w*):

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

Per definire un gruppo lookahead negativo, usare (?! e ) che specificano che il sottomodello del gruppo non deve corrispondere alla posizione. Ad esempio:

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

Uso di gruppi denominati

Un gruppo denominato di un'espressione regolare è un gruppo a cui è stato assegnato un nome. Per definire un gruppo denominato, usare (?P<name> e ). L'espressione regolare dell'esempio seguente contiene il gruppo denominato digits:

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

Quando si usa il metodo exec(), un gruppo denominato corrispondente viene aggiunto come proprietà dell'array 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

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