Flag e proprietà

Flag g (global)

Se il flag g ( global ) non è presente, l'espressione regolare ricerca una sola corrispondenza. Ad esempio, se il flag g non viene impostato nell'espressione regolare, il metodo String.match() restituisce una sola sottostringa corrispondente:

var str:String = "she sells seashells by the seashore."; 
var pattern:RegExp = /sh\w*/; 
trace(str.match(pattern)) // output: she

Quando il flag g è impostato, il metodo Sting.match() restituisce più corrispondenze, come nell'esempio seguente:

var str:String = "she sells seashells by the seashore."; 
var pattern:RegExp = /sh\w*/g; 
// The same pattern, but this time the g flag IS set. 
trace(str.match(pattern)); // output: she,shells,shore

Flag i (ignoreCase)

Per impostazione predefinita, le corrispondenze cercate dalle espressioni regolari distinguono tra maiuscole e minuscole. Quando impostate il flag i ( ignoreCase ), la distinzione tra maiuscole e minuscole viene disattivata. Ad esempio, la lettera minuscola s dell'espressione regolare non rileva la lettera maiuscola S , il primo carattere della stringa:

var str:String = "She sells seashells by the seashore."; 
trace(str.search(/sh/)); // output: 13 -- Not the first character

Quando il flag i è impostato, invece, l'espressione regolare rileva anche la lettera S maiuscola:

var str:String = "She sells seashells by the seashore."; 
trace(str.search(/sh/i)); // output: 0

Il flag i sospende la distinzione tra maiuscole e minuscole solo per i caratteri A – Z e a – z , non per i caratteri del set esteso come É e é .

Flag m (multiline)

Se il flag m ( multiline ) non è impostato, ^ corrisponde alla posizione iniziale della stringa e $ corrisponde alla posizione finale. Quando il flag m è impostato, i caratteri corrispondono, rispettivamente, alla posizione iniziale di una riga e alla posizione finale. Considerate la stringa seguente, che comprende il carattere nuova riga (\n):

var str:String = "Test\n"; 
str += "Multiline"; 
trace(str.match(/^\w*/g)); // Match a word at the beginning of the string.

Anche se il flag g ( global ) è impostato nell'espressione regolare, il metodo match() ricerca solo una sottostringa, poiché è presente una sola corrispondenza per ^ - l'inizio della stringa. Il risultato è il seguente:

Test

Ecco lo stesso frammento di codice con il flag m impostato:

var str:String = "Test\n"; 
str += "Multiline"; 
trace(str.match(/^\w*/gm)); // Match a word at the beginning of lines. 

Questa volta, il risultato include le parole all'inizio delle due righe:

Test,Multiline

Notate che solo il carattere \n indica la fine della riga. I caratteri seguenti non indicano la fine della riga:

• Ritorno a capo ( \r )

• Separatore di riga Unicode ( \u2028 )

• Separatore di paragrafo Unicode ( \u2029 )

Flag s (dotall)

Se il flag s ( dotall ) non è impostato, nelle espressioni regolari un punto ( . ) non corrisponde a un carattere nuova riga ( \n ). Di conseguenza, nell'esempio seguente non viene evidenziata una corrispondenza:

var str:String = "<p>Test\n"; 
str += "Multiline</p>"; 
var re:RegExp = /<p>.*?<\/p>/; 
trace(str.match(re)); 

Tuttavia, se il flag s è impostato, il punto trova il carattere nuova riga:

var str:String = "<p>Test\n"; 
str += "Multiline</p>"; 
var re:RegExp = /<p>.*?<\/p>/s; 
trace(str.match(re)); 

In questo caso, la corrispondenza riguarda l'intera sottostringa racchiusa tra i tag <p> , che comprende anche il carattere nuova riga:

<p>Test 
Multiline</p>

Flag x (extended)

Le espressioni regolari possono risultare abbastanza oscure, specialmente se contengono molti metacaratteri e metasequenze. Ad esempio:

/<p(>|(\s*[^>]*>)).*?<\/p>/gi

L'uso del flag x ( extended ) all'interno di un'espressione regolare permette di aggiungere spazi bianchi che non vengono considerati come parte del modello. L'espressione regolare dell'esempio seguente è identica a quella dell'esempio precedente:

/     <p    (>  | (\s* [^>]* >))    .*?    <\/p>  /gix

Se un'espressione regolare comprende un flag x e desiderate cercare il valore letterale di uno spazio vuoto, anteponete allo spazio una barra rovesciata. Ad esempio, le due espressioni regolari seguenti sono equivalenti:

/foo bar/ 
/foo \ bar/x

Proprietà lastIndex

La proprietà lastIndex specifica la posizione di indice nella stringa in corrispondenza della quale cominciare la ricerca successiva. La proprietà influisce sui metodi exec() e test() chiamati da un'espressione regolare in cui il flag g è impostato su true . Consideriamo l'esempio del codice seguente:

var pattern:RegExp = /p\w*/gi; 
var str:String = "Pedro Piper picked a peck of pickled peppers."; 
trace(pattern.lastIndex); 
var result:Object = pattern.exec(str); 
while (result != null) 
{ 
    trace(pattern.lastIndex); 
    result = pattern.exec(str); 
}

Per impostazione predefinita, la proprietà lastIndex è impostata su 0 (per cominciare le ricerche all'inizio della stringa). Dopo ogni corrispondenza rilevata, viene portata alla posizione di indice successiva. Il risultato per il frammento di codice precedente sarà, pertanto, il seguente:

0 
5 
11 
18 
25 
36 
44

Se il flag global è impostato su false , i metodi exec() e test() non usano né impostano la proprietà lastIndex .

I metodi match() , replace() e search() della classe String avviano tutte le ricerche dall'inizio della stringa, indipendentemente dall'impostazione della proprietà lastIndex dell'espressione regolare usata nella chiamata al metodo. (Tuttavia, il metodo match() imposta lastIndex su 0.)

È possibile impostare la proprietà lastIndex per regolare la posizione iniziale nella stringa per la corrispondenza dell'espressione regolare.

Proprietà source

La proprietà source specifica la stringa che definisce la porzione modello dell'espressione regolare. Ad esempio:

var pattern:RegExp = /foo/gi; 
trace(pattern.source); // foo