Condividi tramite


Alternanza e sottoespressioni

L'alternanza in un'espressione regolare consente di raggruppare scelte tra due o più alternative. È possibile essenzialmente specificare "o questo o quello" in un modello.

Le sottoespressioni consentono di ricercare la corrispondenza di un criterio nel testo e di dividere la corrispondenza in sottocorrispondenze separate. Le sottocorrispondenze risultanti possono essere recuperate dal programma. Le sottoespressioni consentono inoltre di riformattare il testo, come descritto in Backreference in JScript.

Per ulteriori informazioni sulle espressioni regolari, vedere Creazione di un'espressione regolare e Sintassi delle espressioni regolari.

Alternanza

È possibile utilizzare il carattere barra verticale (|) per specificare una scelta tra due o più alternative. Questo meccanismo è noto come alternanza. La ricerca della corrispondenza viene eseguita sull'espressione più estesa possibile prima e dopo il carattere barra verticale. Si potrebbe pensare che la seguente espressione JScript corrisponda alla parola "Capitolo" o "Sezione" seguita da una o due cifre.

/Chapter|Section [1-9][0-9]{0,1}/

Al contrario, l'espressione regolare corrisponde alla parola "Capitolo" o alla parola "Sezione" e a qualsiasi numero successivo alla parola stessa. Se la stringa in cui viene eseguita la ricerca è "Sezione 22", l'espressione corrisponde a "Sezione 22". Tuttavia, se la stringa in cui viene eseguita la ricerca è "Capitolo 22", l'espressione corrisponde alla parola "Capitolo" anziché corrispondere a "Capitolo 22".

Alternanza con parentesi

È possibile utilizzare le parentesi per limitare l'ambito dell'alternanza, ovvero per assicurarsi che venga applicata solo alle parole "Capitolo" e "Sezione". Aggiungendo le parentesi, è possibile fare in modo che l'espressione regolare corrisponda alla parola "Capitolo 1" o alla parola "Sezione 3".

Le parentesi, tuttavia, vengono utilizzate anche per creare una sottoespressione. La sottocorrispondenza risultante può essere recuperata dal programma.

Nella seguente espressione regolare JScript vengono utilizzate le parentesi per raggruppare le parole "Capitolo" e "Sezione". Le possibili corrispondenze includeranno quindi "Capitolo" seguito da un numero.

/(Chapter|Section) [1-9][0-9]{0,1}/

Le parentesi intorno a Chapter|Section causano inoltre il salvataggio delle due parole corrispondenti per un utilizzo futuro.

Nell'esempio riportato di seguito viene illustrato come è possibile recuperare le corrispondenze e le sottocorrispondenze nel codice. Poiché nell'espressione è inclusa solo una coppia di parentesi, viene salvata una sola sottocorrispondenza.

var re = /(Chapter|Section) [1-9][0-9]{0,1}/g
var src = "Chapter 50  Section 85"
ShowMatches(src, re);

// Output:
//  Chapter 50
//  submatch 1: Chapter

//  Section 85
//  submatch 1: Section

// Perform a search on a string by using a regular expression,
// and display the matches and submatches.
function ShowMatches(src, re)
{
    var result;

    // Get the first match.
    result = re.exec(src);
    
    while (result != null)
    {
        // Show the entire match.
        print();
        print(result[0]);

        // Show the submatches.
        for (var index=1; index<result.length; index++)
            {
                print("submatch " + index + ": " + result[index]);
            }

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

Alternanza senza salvataggio di una sottocorrispondenza

Nell'esempio precedente, si desidera utilizzare le parentesi solo per raggruppare un'alternativa tra le parole "Capitolo" e "Sezione".

Per evitare il salvataggio della sottocorrispondenza per un utilizzo successivo, è possibile specificare la sottoespressione (?:pattern). Nell'esempio riportato di seguito, viene eseguita la stessa operazione dell'esempio precedente, ma in questo caso non viene salvata la sottocorrispondenza.

var re = /(?:Chapter|Section) [1-9][0-9]{0,1}/g
var src = "Chapter 50  Section 85"
ShowMatches(src, re);
// Output:
//  Chapter 50
//  Section 85

Sottoespressioni

L'inserimento di parentesi in un'espressione regolare consente di creare una sottoespressione. La sottocorrispondenza risultante può essere recuperata dal programma.

Nell'esempio riportato di seguito, l'espressione regolare contiene tre sottoespressioni. Le stringhe delle sottocorrispondenze vengono visualizzate insieme a ogni corrispondenza.

var re = /(\w+)@(\w+)\.(\w+)/g
var src = "Please send mail to george@contoso.com and someone@example.com. Thanks!"
ShowMatches(src, re);
// The ShowMatches function is provided earlier.

// Output:
//  george@contoso.com
//  submatch 1: george
//  submatch 2: contoso
//  submatch 3: com

//  someone@example.com
//  submatch 1: someone
//  submatch 2: example
//  submatch 3: com

Nell'esempio riportato di seguito viene suddiviso un URI (Universal Resource Indicator) nelle diverse parti che lo compongono.

La prima sottoespressione tra parentesi salva la parte dell'indirizzo Web relativa al protocollo. Corrisponde a qualsiasi parola che precede un carattere due punti e due barre. La seconda sottoespressione tra parentesi salva la parte dell'indirizzo relativa all'indirizzo di dominio. Corrisponde a qualsiasi sequenza di caratteri che non comprende i caratteri barra (/) o due punti (:). La terza sottoespressione tra parentesi salva il numero di porta del sito Web, eventualmente specificato. Corrisponde a zero o più cifre che seguono il carattere due punti. La quarta espressione tra parentesi salva le informazioni relative al percorso e/o alla pagina specificate nell'indirizzo Web. Corrisponde a zero o più caratteri diversi dal carattere del simbolo cancelletto (#) o dal carattere spazio.

var re = /(\w+):\/\/([^\/:]+)(:\d*)?([^# ]*)/gi;
var src = "https://msdn.microsoft.com:80/scripting/default.htm";
ShowMatches(src, re);

// Output:
//  https://msdn.microsoft.com:80/scripting/default.htm
//  submatch 1: http
//  submatch 2: msdn.microsoft.com
//  submatch 3: :80
//  submatch 4: /scripting/default.htm

Lookahead positivi e negativi

Un lookahead positivo è un tipo di ricerca in cui, una volta trovata una corrispondenza, la ricerca della corrispondenza successiva inizia prima del testo di cui è stata individuata la corrispondenza. La corrispondenza non viene salvata per un utilizzo successivo. Per specificare un lookahead positivo, utilizzare la sintassi (?=pattern).

Nell'esempio riportato di seguito, viene eseguita una ricerca per determinare se la lunghezza di una password è compresa tra 4 e 8 caratteri e se contiene almeno una cifra.

Nell'espressione regolare, l'espressione .*\d trova qualsiasi numero di caratteri seguito da una cifra. Per la stringa in cui viene eseguita la ricerca "abc3qr", questo corrisponde a "abc3". Iniziando prima, anziché dopo, tale corrispondenza, .{4,8} corrisponderà a una stringa di 4-8 caratteri. Corrisponde a "abc3qr".

^ e $ specificano le posizioni all'inizio e alla fine della stringa in cui viene eseguita la ricerca. Ciò consente di evitare l'individuazione di una corrispondenza quando la stringa in cui viene eseguita la ricerca contiene caratteri al di fuori dei caratteri corrispondenti.

var re = /^(?=.*\d).{4,8}$/gi
var src = "abc3qr"
ShowMatches(src, re);
// The ShowMatches function is provided earlier.
// Output:
//  abc3qr

Un lookahead negativo esegue la ricerca di una stringa che non corrisponde al criterio in un'espressione di lookahead negativo. Dopo l'individuazione di una corrispondenza, la ricerca della corrispondenza successiva inizierà prima del testo di cui è stata individuata la corrispondenza. La corrispondenza non viene salvata per un utilizzo successivo. Per specificare un lookahead negativo, utilizzare la sintassi (?!pattern).

Nell'esempio riportato di seguito viene ricercata la corrispondenza delle parole che non iniziano con "th".

Nell'espressione regolare, \b corrisponde a un inizio o a una fine di parola. Per la stringa in cui viene eseguita la ricerca " quick ", questo corrisponde al primo spazio. (?!th) corrisponde a una stringa che non è "th". Corrisponde a "qu". Avviandosi prima di tale corrispondenza, \w+ corrisponde a una parola. Corrisponde a "quick".

var re = /\b(?!th)\w+\b/gi
var src = "The quick brown fox jumps over the lazy dog."
ShowMatches(src, re);
// Output:
//  quick
//  brown
//  fox
//  jumps
//  over
//  lazy
//  dog

Vedere anche

Concetti

Backreference in JScript

Altre risorse

Introduzione alle espressioni regolari