Gruppi

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*/ ; 
// 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

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

Per ulteriori informazioni sui quantificatori, vedete Quantificatori .

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/; 
// matches cat or dog 
 
pattern = /ca(t|d)og/; 
// matches catog or cadog

Uso dei gruppi per rilevare corrispondenze a sottostringhe

Se all'interno di un modello definite un gruppo parentetico standard, potete aggiungere dei riferimenti al gruppo in un punto successivo dell'espressione regolare. Questi tipi di riferimenti sono definiti a posteriori e questi tipi di gruppi sono conosciuti come gruppi di cattura . Ad esempio, nell'espressione regolare seguente, la sequenza \1 corrisponde alla sottostringa individuata dal gruppo di cattura parentetico:

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

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

Analogamente, nel metodo replace() della classe String, potete 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 usate i gruppi di cattura, il metodo exec() della classe RegExp 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@example.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. Usate (?: e ) per definire i gruppi di non cattura come descritto di seguito:

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

Ad esempio, notate 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@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

Il gruppo lookahead è un tipo speciale di gruppo di non cattura, di cui esistono due tipi: il gruppo lookahead positivo e il gruppo lookahead negativo .

Per definire un gruppo lookahead positivo, usate (?= 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, usate (?! 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, usate (?P<nome> e ) . L'espressione regolare dell'esempio seguente contiene il gruppo denominato digits :

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

Quando usate 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

Segue un altro esempio che contiene due gruppi denominati ( 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