Flag e proprietà -- Flash CS3

La tabella seguente elenca i cinque flag che si possono impostare per le espressioni regolari. È possibile accedere a ogni flag come proprietà dell'oggetto espressione regolare.

Flag	Proprietà	Descrizione
`g`	`global`	Cerca più corrispondenze.
`i`	`ignoreCase`	Cerca corrispondenze ignorando maiuscole e minuscole. Si riferisce ai caratteri `A` - `Z` e `a` - `z` senza includere i caratteri del set esteso (come `É` e `é`).
`m`	`multiline`	Quando questo flag è impostato, `$` e `^` corrispondono, rispettivamente, alla posizione iniziale di una riga e alla posizione finale.
`s`	`dotall`	Quando questo flag è impostato, `.` (punto) può corrispondere al carattere nuova riga (`\n`).
`x`	`extended`	Consente di usare espressioni regolari estese. L'espressione regolare può contenere spazi, che non vengono considerati come parte del modello, al fine di rendere il codice dell'espressione più leggibile.

Si noti che le proprietà sono di sola lettura. Si possono impostare i flag (g, i, m, s, x) quando si imposta la variabile di un'espressione regolare come segue:

var re:RegExp = /abc/gimsx;

Non è, tuttavia, possibile impostare direttamente le proprietà denominate. Ad esempio, il codice seguente genera un errore:

var re:RegExp = /abc/;
re.global = true; // Questo genera un errore.

Per impostazione predefinita, a meno che non siano stati specificati nella dichiarazione dell'espressione regolare, i flag non sono impostati e le proprietà corrispondenti sono impostate su false.

Sezioni

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;
// Stesso modello, ma con il flag g IMPOSTATO.
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 si imposta 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 -- Il primo carattere è escluso

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. Si consideri la stringa seguente, che comprende il carattere nuova riga (\n):

var str:String = "Test\n";
str += "Multiline";
trace(str.match(/^\w*/g)); // Corrisponde a una parola all'inizio della stringa.

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

var str:String = "Test\n";
str += "Multiline";
trace(str.match(/^\w*/gm)); // Cerca una parola all'inizio delle righe.

Test,Multiline

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

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

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 si desidera cercare il valore letterale di uno spazio vuoto, anteporre 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:

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