Ricerca di sottostringhe e modelli nelle stringhe -- Flash CS3

Le sottostringhe sono caratteri sequenziali all'interno di una stringa. Ad esempio, la stringa "abc" presenta le seguenti sottostringhe: "", "a", "ab", "abc", "b", "bc", "c". I metodi di ActionScript consentono di individuare le sottostringhe di una stringa.

I modelli vengono definiti in ActionScript da stringhe o da espressioni regolari. Ad esempio, la seguente espressione regolare definisce un modello specifico, le lettere A, B e C seguite da un carattere di digitazione (il carattere barra è un delimitatore delle espressioni regolari):

ActionScript include metodi per cercare i modelli nelle stringhe e per sostituire le corrispondenze trovate con sottostringhe. Tali metodi vengono descritti più dettagliatamente nelle sezioni che seguono.

Le espressioni regolari sono in grado di definire modelli intricati. Per ulteriori informazioni, vedere Uso delle espressioni regolari.

Sezioni

Ricerca di una sottostringa in base alla posizione del carattere

I metodi substr() e substring() sono simili. Entrambi restituiscono infatti una sottostringa di una stringa e accettano due parametri. In entrambi i metodi, il primo parametro corrisponde alla posizione del carattere iniziale della stringa. Nel metodo substr(), tuttavia, il secondo parametro corrisponde alla lunghezza della sottostringa da restituire, mentre nel metodo substring() il secondo parametro definisce la posizione del carattere alla fine della sottostringa (che non è incluso nella stringa restituita). Nell'esempio seguente viene illustrata la differenza tra questi due metodi:

var str:String = "Hello from Paris, Texas!!!";
trace(str.substr(11,15)); // output: Paris, Texas!!!
trace(str.substring(11,15)); // output: Pari

Il funzionamento del metodo slice() è analogo al metodo substring(). Se si utilizzano come parametri due numeri interi non negativi, il risultato è identico. Con il metodo slice() è tuttavia possibile utilizzare come parametri numeri interi negativi, nel qual caso la posizione del carattere viene rilevata dalla fine della stringa, come nell'esempio seguente:

var str:String = "Hello from Paris, Texas!!!";
trace(str.slice(11,15)); // output: Pari
trace(str.slice(-3,-1)); // output: !!
trace(str.slice(-3,26)); // output: !!!
trace(str.slice(-3,str.length)); // output: !!!
trace(str.slice(-8,-3)); // output: Texas

Come parametri del metodo slice(), è possibile combinare numeri interi non negativi e negativi.

Individuazione della posizione del carattere di una sottostringa corrispondente

I metodi indexOf() e lastIndexOf() possono essere utilizzati per individuare le sottostringhe corrispondenti in una stringa, come illustrato nell'esempio seguente:

var str:String = "The moon, the stars, the sea, the land";
trace(str.indexOf("the")); // output: 10

Per indicare la posizione di indice nella stringa dalla quale iniziare la ricerca, è possibile specificare un secondo parametro, come di seguito:

var str:String = "The moon, the stars, the sea, the land"
trace(str.indexOf("the", 11)); // output: 21

Il metodo lastIndexOf() trova l'ultima occorrenza di una sottostringa nella stringa:

var str:String = "The moon, the stars, the sea, the land"
trace(str.lastIndexOf("the")); // output: 30

Se con il metodo lastIndexOf() si include un secondo parametro, la ricerca viene eseguita all'indietro (da destra a sinistra) a partire dalla posizione di indice nella stringa:

var str:String = "The moon, the stars, the sea, the land"
trace(str.lastIndexOf("the", 29)); // output: 21

Creazione di un array di sottostringhe segmentate da un delimitatore

È possibile utilizzare il metodo split() per creare un array di sottostringhe divise in base a un carattere delimitatore. Ad esempio, è possibile segmentare una stringa delimitata da virgole o da tabulazioni in più stringhe.

L'esempio seguente mostra come dividere un array in sottostringhe con la e commerciale (&) come delimitatore:

var queryStr:String = "first=joe&last=cheng&title=manager&StartDate=3/6/65";
var params:Array = queryStr.split("&", 2); // params == ["first=joe","last=cheng"]

Il secondo parametro del metodo split(), che è opzionale, definisce le dimensioni massime dell'array restituito.

È possibile utilizzare anche un'espressione regolare come carattere delimitatore:

var str:String = "Give me\t5."
var a:Array = str.split(/\s+/); // a == ["Give","me","5."]

Per ulteriori informazioni, vedere Uso delle espressioni regolari e Guida di riferimento del linguaggio e ai componenti ActionScript 3.0.

Ricerca di modelli nelle stringhe e sostituzione di sottostringhe

La classe String include i seguenti metodi per eseguire operazioni con i modelli all'interno delle stringhe:

È possibile utilizzare stringhe o espressioni regolari per definire i modelli utilizzati in questi metodi. Per ulteriori informazioni sulle espressioni regolari, vedere Uso delle espressioni regolari.

Ricerca di sottostringhe corrispondenti

Il metodo search() restituisce la posizione di indice della prima sottostringa corrispondente a un dato modello, come nell'esempio seguente:

var str:String = "The more the merrier.";
// (Nella ricerca si fa distinzione tra lettere maiuscole e minuscole.)
trace(str.search("the")); // output: 9

È possibile utilizzare espressioni regolari per definire il modello da utilizzare come corrispondenza, come illustrato nell'esempio seguente:

var pattern:RegExp = /the/i;
var str:String = "The more the merrier.";
trace(str.search(pattern)); // 0

Il risultato del metodo trace() è 0, in quanto il primo carattere della stringa si trova nella posizione di indice. L'indicatore i viene impostato nell'espressione regolare, in modo che nella ricerca non si faccia distinzione tra maiuscole e minuscole.

Il metodo search() consente di trovare solo una corrispondenza e restituisce la sua posizione di indice iniziale, anche se l'indicatore g (global) viene impostato nell'espressione regolare.

Nell'esempio seguente è illustrata un'espressione regolare più complessa, che deve corrispondere a una stringa racchiusa tra virgolette doppie:

var pattern:RegExp = /"[^"]*"/;
var str:String = "The \"more\" the merrier.";
trace(str.search(pattern)); // output: 4

str = "The \"more the merrier.";
trace(str.search(pattern)); // output: -1 
// (Indica nessuna corrispondenza, in quanto mancano le virgolette doppie di chiusura.)

Il metodo match() funziona in modo simile. Esso consente di cercare una sottostringa corrispondente. Tuttavia, se si usa l'indicatore global in un modello di espressione regolare, come nell'esempio seguente, il metodo match() restituisce un array di sottostringhe corrispondenti:

var str:String = "bob@example.com, omar@example.org";
var pattern:RegExp = /\w*@\w*\.[org|com]+/g;
var results:Array = str.match(pattern);

["bob@example.com","omar@example.org"]

Sostituzione di sottostringhe corrispondenti

Utilizzare il metodo replace() per cercare un modello specifico all'interno di una stringa e sostituire le corrispondenze trovate con la stringa specificata, come illustrato nell'esempio seguente:

var str:String = "She sells seashells by the seashore.";
var pattern:RegExp = /sh/gi;
trace(str.replace(pattern, "sch"));
    //sche sells seaschells by the seaschore.

Si noti come, nell'esempio, nelle stringe corrispondenti non si fa distinzione tra lettere maiuscole e minuscole, in quanto è stato impostato l'indicatore i (ignoreCase) nell'espressione regolare e le corrispondenze multiple vengono sostituite in quanto è stato specificato l'indicatore g (global). Per ulteriori informazioni, vedere Uso delle espressioni regolari.

Nella stringa di sostituzione è possibile includere i seguenti codici di sostituzione $. Il testo di sostituzione visualizzato nella tabella seguente viene inserito al posto del codice di sostituzione $ :

Codice $	Testo sostitutivo
`$$`	$
`$&`	Sottostringa di cui si è trovata la corrispondenza.
$`	Porzione della stringa che precede la sottostringa di cui si è trovata la corrispondenza. In questo codice viene impiegato il carattere virgoletta singola dritta sinistra (`) e non la virgoletta dritta singola (`'`) o la virgoletta singola curva sinistra (`'`).
`$'`	La porzione della stringa che segue la sottostringa di cui si è trovata la corrispondenza. In questo codice viene utilizzata la virgoletta singola dritta (`'`).
`$`n	Corrispondenza con l'nsimo gruppo parentetico catturato, dove n è un numero a cifra singola compreso tra 1 e 9 e $n non è seguito da una cifra decimale.
`$`nn	Corrispondenza con l'nnsimo gruppo parentetico catturato, dove nn è un numero decimale a due cifre compreso tra 01 e 99. Se l'nnsima cattura non è definita, il testo di sostituzione è una stringa vuota.

Ad esempio, il codice seguente illustra l'utilizzo dei codici sostitutivi $2 e $1, che rappresentano il primo e il secondo gruppo di cattura di cui è stata trovata una corrispondenza:

var str:String = "flip-flop";
var pattern:RegExp = /(\w+)-(\w+)/g;
trace(str.replace(pattern, "$2-$1")); // flop-flip

È possibile usare una funzione come secondo parametro del metodo replace(). Il testo corrispondente viene sostituito dal valore restituito dalla funzione.

var str:String = "Now only $9.95!";
var price:RegExp = /\$([\d,]+.\d+)+/i;
trace(str.replace(price, usdToEuro));

function usdToEuro(matchedSubstring:String, 
                                 capturedMatch1:String, 
                                 index:int, 
                                 str:String):String
{
    var usd:String = capturedMatch1;
    usd = usd.replace(",", "");
    var exchangeRate:Number = 0.853690;
    var euro:Number = usd * exchangeRate;
    const euroSymbol:String = String.fromCharCode(8364);
    return euro.toFixed(2) + " " + euroSymbol;
}

Se si usa una funzione come secondo parametro del metodo replace(), alla funzione vengono inviati i seguenti argomenti: