Nessun risultato. Prova con un altro termine.
Guide
Notizie
Software
Tutorial

Espressioni regolari in Actionscript 3

Con ActionScript 3 è stata introdotta la possibilità di utilizzare le espressioni regolari. Nell'articolo facciamo una breve panoramica su cosa sono e come si utilizzano in Flash e Flex 2 e 3.
Con ActionScript 3 è stata introdotta la possibilità di utilizzare le espressioni regolari. Nell'articolo facciamo una breve panoramica su cosa sono e come si utilizzano in Flash e Flex 2 e 3.
Link copiato negli appunti

Le espressioni regolari sono utilizzate per analizzare testi e stringhe e controllare se rispettano determinati parametri; ad esempio, è possibile utilizzarle per validare l'immissione di un indirizzo e-mail in un form.

Questa tecnologia esiste da diverso tempo ed è presente in molti linguaggi, ma in Actionscript è stata introdotta solamente nell'ultima versione e quindi è possibile utilizzare le espressioni regolari in Flex (versioni 2 e 3) e Flash (versione CS3).

Prima di vedere nello specifico come applicare un'espressione regolare in Actionscript può essere necessaria una piccola introduzione al loro funzionamento; poiché le espressioni regolari sono composte da uno schema di caratteri, è bene comprendere come realizzare tale schema.

L'esempio più semplice è quello di una determinata serie di caratteri, supponiamo di voler cercare la stringa ABC in un testo, lo schema da utilizzare sarà:

/ABC/

Potremmo invece voler cercare un numero o una lettera qualsiasi, senza specificare precisamente quale, per questo si possono usare le seguenti stringhe:

  • d - Qualsiasi numero
  • w - Qualsiasi carattere alfanumerico
  • s - Qualsiasi spazio o tabulazione

Ne consegue che ad esempio lo schema

/ABCd/

Cercherà nella stringa i testi ABC0, ABC1, ABC2, ABC3, ABC4, ABC5, ABC6, ABC7, ABC8, ABC9, quindi se la nostra stringa fosse ad esempio ABC8helloworld l'espressione regolare restituirebbe ABC8, ignorando la parte seguente della stringa.

Qualora volessimo ricavare l'intera stringa potremmo modificare la nostra espressione regolare così:

/ABCd*/

Notiamo la presenza dell'asterisco che, in un'espressione regolare, significa zero o più volte (riferito al carattere precedente).

Questo significa anche che l'espressione regolare appena vista cerca una stringa che inizi con ABC e che abbia di seguito un qualsiasi numero di caratteri alfanumerici, per cui se usata sulla stringa ABC8helloworld la restituirebbe per intero.

Altri caratteri utilizzabili per il conteggio sono:

  • +: il carattere deve essere presente una o più volte;
  • ?: il carattere deve essere presente zero o una volta;
  • {n}: il carattere deve essere presente esattamente n volte;
  • {n,}: il carattere deve essere presente n o più volte;
  • {n,o}: il carattere deve essere presente da un minimo di n ad un massimo di m volte;

Questi caratteri sono detti quantificatori e vanno abbinati ad un carattere o ad un insieme di caratteri.

È possibile creare un insieme di caratteri usando le parentesi quadre, ecco alcuni esempi:

  • [abc]: cerca la lettera a,b o c
  • [a-q]: cerca una lettera da a a q
  • [A-Q]: cerca una lettera maiuscola da A a Q
  • [0-8]: cerca un numero da 0 a 8

Gli insiemi usati più spesso sono ovviamente [a-z], [A-Z] e [0-9]. È anche possibile creare degli insiemi specifici di caratteri usando le parentesi tonde, per esempio (ABC) da lo stesso risultato di ABC; all'interno di questi insiemi è possibile impostare più alternative, per esempio con (it|net|com|org) ammettiamo l'utilizzo delle combinazioni it, net, org e com.

Applicare le espressioni regolari in Actionscript

Dopo aver analizzato brevemente alcune caratteristiche delle espressioni regolari vediamo come utilizzarle in Actionscript 3 per trovare ed eventualmente sostituire parti di una stringa. Il codice da usare è semplicissimo ed è di questo tipo:

Listato 1. Cerca e sostituisce parti di testo

// impostiamo una variabile contenente l'espressione regolare
var pattern:RegExp = /ABC/

// impostiamo la stringa a cui applicheremo l'espressione
var stringa:String = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

// restituirà 0
trace(stringa.search(pattern))

Perché il trace ci restituisce 0? Perché il metodo search restituisce il primo carattere della corrispondenza eventualmente trovata nella stringa, nel nostro caso 0 (ovvero il primo carattere) poiché la combinazione ABC è posta all'inizio; se avessimo avuto il seguente codice il risultato sarebbe stato 9, perché la combinazione ABC inizia al decimo carattere.

Listato 2. Cerca e sostituisce in una stringa

// impostiamo una variabile contenente l'espressione regolare
var pattern:RegExp = /ABC/

// impostiamo la stringa a cui applicheremo l'espressione
var stringa:String = "123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

// restituirà 9
trace(stringa.search(pattern))

Qualora la combinazione impostata nell'espressione regolare non fosse presente nella stringa verrebbe invece restituito il valore -1.

Altri metodi che si possono utilizzare sono match (cerca l'esatta corrispondenza e restituisce il testo), replace (sostituisce il testo con una nuova stringa specificata nella funzione) e split (divide la stringa in più parti usando come separatore la stringa corrispondente all'espressione regolare). Possiamo testare i differenti risultati così:

Listato 3. Cerca in una stringa e usa vari metodi per restituire i risultati

// impostiamo una variabile contenente l'espressione regolare
var pattern:RegExp = /ABC/

// impostiamo la stringa a cui applicheremo l'espressione
var stringa:String = "12345ABC6789";

// restituirà 5
trace(stringa.search(pattern))

// restituirà ABC
trace(stringa.match(pattern))

// restituirà 12345, 6789
trace(stringa.split(pattern))

// restituirà 12345CAMBIO6789
trace(stringa.replace(pattern,"CAMBIO"))

La classe RegExp offre invece il metodo test, che restituisce true o false se la stringa analizzata rispetta o meno l'espressione impostata.

Ovviamente con le espressioni regolari si possono realizzare schemi ben più complessi in grado di validare stringhe molto lunghe e con molti caratteri; quale che sia la complessità del pattern utilizzato, il codice Actionscript per l'uso dell'espressione regolare su una stringa rimane il medesimo.

Utilizzando le nozioni di base apprese in questo articolo potremmo creare ad esempio un'espressione regolare per validare un URL.

Listato 4. Valida un URL

var url:RegExp = /http://(www).w*.(it|net|com)/

var _stringa = "http://www.google.com"

var _stringa2 = "www.google.com"

var _stringa3 = "http://www.google"

trace(url.test(_stringa)) // true

trace(url.test(_stringa2)) // false (non inizia con http://)

trace(url.test(_stringa3)) // false (manca l'estensione)

La stringa deve iniziare con http:// (http://, i due backslash servono solo come caratteri di escape), quindi deve avere un punto (.), quindi può contenere un numero qualsiasi di caratteri alfanumerici (w*); dopo di che è necessario un altro punto (.) che sarà seguito da un'estensione che in questo caso può essere it, net o com ( (it|net|com) ).

È interessante notare come diversi schemi possano portare ad uno stesso risultato: l'esempio più eclatante è la validazione di un indirizzo e-mail, per cui cercando delle espressioni regolari già realizzate troviamo una grande quantità di pattern diversi tra loro in maniera più o meno rilevante.

Chi ha già avuto occasione di usare Actionscript 3 per agire sulle stringhe può aver notato che i comandi split, search e replace sono utilizzabili anche passando come parametro una stringa e non un'espressione regolare; il vantaggio però è dato dal fatto che con queste ultime è possibile analizzare in maniera più dettagliata e anche più complessa i testi, rendendo molto più versatile il controllo: supponiamo che ci venga inviata da un servizio esterno una stringa che conterrà un testo e un numero sempre diversi e di dover eliminare il numero dalla stringa; senza le espressioni regolari sarebbe piuttosto complesso, dato che non conosciamo né la lunghezza del testo che ci viene inviato né la posizione del numero, né tanto meno il valore di tale numero.

Con le espressioni regolari bastano invece poche righe di codice:

Listato 5. Elimina il numero da una stringa

var pattern:RegExp = /[0-9]/

var stringa1 = "ciao1mondo"

var stringa2 = "htmlitèunportale2diinformazionetecnologica"

var stringa3 = "a3bcde"

var stringa4 = "htmlit1èunportale2diinformazione3tecnologica"

trace(stringa1.split(pattern))

trace(stringa2.split(pattern))

trace(stringa3.split(pattern))

trace(stringa4.split(pattern))

I risultati saranno:

  • ciao,mondo
  • htmlitèunportale,diinformazionetecnologica
  • a,bcde
  • htmlit,èunportale,diinformazione,tecnologica

Usando l'insieme [0-9] praticamente abbiamo dato istruzione di applicare lo split in qualsiasi punto della stringa dove sia presente un numero: questo vuol dire che qualsiasi valore ci arrivi, saremo sempre sicuri che lo split verrà eseguito correttamente.

Questo è solo un esempio di come le espressioni regolari permettano di analizzare dati di cui potremmo non conoscere l'esatto valore.

Conclusioni e riferimenti utili

Le espressioni regolari possono essere utili principalmente per la validazione di input dell'utente come ad esempio la compilazione di un form, o per l'analisi di dati provenienti dall'esterno. Actionscript 3 supporta pressoché pienamente questa tecnologia e grazie al fatto che la sintassi da usare per creare i pattern è la medesima per tutti i linguaggi è possibile sfruttare anche i tutorial non prettamente legati ad Actionscript.

Alcune risorse utili sull'apprendimento delle espressioni regolari sono il sito Regular-Expressions.info e un cheatsheet messo a disposizione dal blog I love Jack Daniels, in Italiano, oltre all'articolo di Giancarlo Moschitta, esiste un'ottima guida sul blog kerouac3001.com.

Adobe stessa mette invece a disposizione una applicazione di esempio creata con Actionscript 3 e disponibile nell'archivio ZIP di esempi relativi a Flash scaricabile dal sito Adobe.


Ti consigliamo anche