Programmazione di un'espressione regolare

In JScript le espressioni regolari possono essere utilizzate per cercare i modelli in una stringa, per sostituire un testo e per estrarre le sottostringhe.

Ricerca

Nell'esempio JScript seguente vengono trovate tutte le occorrenze di una parola.

L'istruzione che consente di creare l'espressione regolare è

var re = /\w+/g;

Il modello /\w+/ specifica la richiesta di corrispondenza con almeno uno dei caratteri seguenti: A-Z, a-z, 0-9 e il carattere di sottolineatura. Il flag g (globale) che segue il modello specifica che in una ricerca devono essere individuate tutte le occorrenze del modello anziché solo la prima.

È possibile utilizzare anche la seguente sintassi JScript alternativa.

var re = new RegExp("\\w+", "g");

Per recuperare ogni corrispondenza, Metodo exec consente di continuare la ricerca, partendo dalla posizione di lastIndex, finché non viene restituito null.

function SearchGlobal()
{
    var src = "The quick brown fox jumps over the lazy dog.";

    // Create a regular expression pattern that has a global flag.
    var re = /\w+/g;

    var result;

    // Get the first match.
    result = re.exec(src);
    while (result != null)
    {
        print (result.index + "-" + result.lastIndex + "\t" + result[0]);

        // Get the next match.
        // Because the global flag is set, the search starts at the
        // position of lastIndex.
        result = re.exec(src);
    }

    // Output:
    //  0-3 The
    //  4-9 quick
    //  10-15 brown
    //  16-19 fox
    //  20-25 jumps
    //  26-30 over
    //  31-34 the
    //  35-39 lazy
    //  40-43 dog
}

Nell'esempio seguente viene trovata solo la prima corrispondenza. Poiché il flag globale (g) non è impostato, la ricerca viene avviata dall'inizio della stringa di ricerca.

function SearchNonGlobal()
{
    var src = "The quick brown fox jumps over the lazy dog.";

    // Create a regular expression that does not have
    // a global flag.
    var re = /\w+/;

    // Get the first match.
    // Because the global flag is not set, the search starts
    // from the beginning of the string.
    var result = re.exec(src);

    if (result == null)
        print ("not found");
    else
        {   
        print (result.index + "-" + result.lastIndex + "\t" + result[0]);
        }

    // Output:
    //  0-3 The
}

Sostituzione

Nell'esempio seguente le occorrenze di "the" vengono sostituite con "a". L'istanza della parola "The" non viene sostituita poiché il flag i (che consente di ignorare la distinzione tra maiuscole e minuscole) non è incluso nei flag dell'espressione regolare.

Nell'esempio viene utilizzato l'oggetto Metodo replace.

function ReplaceGlobal()
{
    var src = "The batter hit the ball with the bat ";
    src += "and the fielder caught the ball with the glove.";

    // Replace "the" with "a".
    var re = /the/g;
    var result = src.replace(re, "a");

    print(result);

    // Output:
    //  The batter hit a ball with a bat and a fielder caught a ball with a glove.
}

Estrazione di sottostringhe

Se in un modello di espressione regolare vengono posizionate delle parentesi, viene creata una sottocorrispondenza che può essere archiviata per un uso successivo.

Nell'esempio seguente, nel modello sono incluse tre sottocorrispondenze. Le stringhe delle sottocorrispondenze vengono visualizzate insieme a ogni corrispondenza.

L'oggetto Metodo exec restituisce una matrice. Nell'elemento zero della matrice è contenuta la corrispondenza completa, mentre negli elementi compresi tra 1 e n sono incluse le sottocorrispondenze.

function SearchWithSubmatches()
{
    var result;

    var src = "Please send mail to george@contoso.com and someone@example.com. Thanks!";

    // Create a regular expression to search for an e-mail address.
    // Include the global flag.
    // (More sophisticated RegExp patterns are available for
    // matching an e-mail address.)
    var re = /(\w+)@(\w+)\.(\w+)/g;

    // Get the first match.
    result = re.exec(src);
    while (result != null)
    {
        print ("e-mail address: " + result[0]);

        // Get the submatched parts of the address.
        print ("user name: " + result[1]);
        print ("host name: " + result[2]);
        print ("top-level domain: " + result[3]);
        print ("");

        // Get the next match.
        result = re.exec(src);
    }

    // Output:
    //  e-mail address: george@contoso.com
    //  user name: george
    //  host name: contoso
    //  top-level domain: com

    //  e-mail address: someone@example.com
    //  user name: someone
    //  host name: example
    //  top-level domain: com
}

Flag

Nell'espressione regolare /abc/gim di JScript, la lettera g specifica il flag globale, la i il flag che consente di ignorare la distinzione tra maiuscole e minuscole e la m specifica il flag su più righe.

Nella tabella seguente sono illustrati i flag consentiti.

Flag di JScript	Se il flag è presente
g	Vengono individuate tutte le occorrenze del modello nella stringa in cui viene eseguita la ricerca anziché solo la prima.
i	La ricerca prevede la distinzione tra maiuscole e minuscole.
m	^ corrisponde alle posizioni che seguono una lettera \n o \r e $ corrisponde alle posizioni che precedono una lettera \n o \r. Indipendentemente dalla presenza del flag, ^ corrisponde alla posizione all'inizio della stringa in cui viene eseguita la ricerca e $ corrisponde alla posizione alla fine della stringa in cui viene eseguita la ricerca.

Funzionalità aggiuntive

Sono disponibili le seguenti funzionalità di programmazione aggiuntive.

Funzionalità	Descrizione
Metodo compile (Visual Studio - JScript)	Consente di compilare un'espressione regolare in un formato interno che ne rende più rapida l'esecuzione.
Metodo test	Consente di verificare l'eventuale presenza di un modello in una stringa in cui viene eseguita la ricerca.
Metodo search	Viene restituita la posizione della prima corrispondenza.

Vedere anche

Riferimenti

Oggetto Regular Expression

Concetti

Creazione di un'espressione regolare

Sintassi delle espressioni regolari