Costrutti di raggruppamento

Aggiornamento: novembre 2007

I costrutti di raggruppamento delineano sottoespressioni di un'espressione regolare e in genere acquisiscono sottostringhe di una stringa di input. Nella tabella riportata di seguito vengono descritti i costrutti di raggruppamento delle espressioni regolari.

Costrutto di raggruppamento	Descrizione
(sottoespressione)	Acquisisce la sottoespressione corrispondente o il gruppo di non acquisizione. Per ulteriori informazioni, vedere l'opzione ExplicitCapture in Opzioni di espressioni regolari. Le acquisizioni tramite () sono numerate automaticamente in base all'ordine della parentesi di apertura, iniziando da uno. La prima acquisizione, quella dell'elemento numero zero, è il testo corrispondente all'intero criterio dell'espressione regolare.
(?<name>sottoespressione)	Acquisisce la sottoespressione corrispondente in un nome di gruppo o un nome di numero. La stringa utilizzata per name non deve contenere punteggiatura e non può iniziare con un numero. È possibile utilizzare virgolette singole al posto di parentesi angolari, ad esempio (?'name').
(?<name1-name2>sottoespressione)	Definizione di gruppo di bilanciamento. Elimina la definizione del gruppo name2 precedentemente definito e memorizza nel gruppo name1 l'intervallo tra il gruppo name2 precedentemente definito e il gruppo corrente. Se non viene definito alcun gruppo name2, viene eseguito il backtracking della corrispondenza. Poiché l'eliminazione dell'ultima definizione di name2 implica il rivelamento della precedente definizione di name2, questo costrutto consente di utilizzare lo stack di acquisizioni del gruppo name2 come contatore per tenere traccia dei costrutti nidificati, ad esempio le parentesi. Nel costrutto l'uso di name1 è facoltativo. È possibile utilizzare virgolette singole al posto di parentesi angolari, ad esempio (?'name1-name2'). Per ulteriori informazioni, vedere l'esempio in questo argomento.
(?:sottoespressione)	Gruppo di non acquisizione. Non acquisisce la sottostringa corrispondente alla sottoespressione.
(?imnsx-imnsx:sottoespressione)	Applica o disattiva le opzioni specificate all'interno della sottoespressione. Ad esempio, (?i-s: ) attiva la modalità di non distinzione tra maiuscole e minuscole e disattiva la modalità a riga singola. Per ulteriori informazioni vedere Opzioni di espressioni regolari.
(?=sottoespressione)	Asserzione lookahead positiva a larghezza zero. Continua a eseguire corrispondenze solo se la sottoespressione corrisponde a questa posizione sulla destra. Ad esempio, \w+(?=\d) corrisponde a una parola seguita da una cifra, ma non c'è corrispondenza con la cifra. Il costrutto non esegue il backtracking.
(?!sottoespressione)	Asserzione lookahead negativa a larghezza zero. Continua a eseguire corrispondenze solo se la sottoespressione non corrisponde alla posizione specificata sulla destra. Ad esempio, \b(?!un)\w+\b corrisponde a parole che non iniziano per un.
(?<=sottoespressione)	Asserzione lookbehind positiva a larghezza zero. Continua a eseguire corrispondenze solo se la sottoespressione corrisponde alla posizione specificata sulla sinistra. Ad esempio, (?<=19)99 corrisponde a istanze di 99 che seguono 19. Il costrutto non esegue il backtracking.
(?<!sottoespressione)	Asserzione lookbehind negativa a larghezza zero. Continua a eseguire corrispondenze solo se la sottoespressione non corrisponde alla posizione specificata sulla sinistra.
(?>sottoespressione)	Sottoespressione che non esegue il backtracking, nota anche come sottoespressione "esigente". La sottoespressione trova una corrispondenza piena una sola volta, quindi non partecipa al backtracking in segmenti. La sottoespressione corrisponde pertanto solo a stringhe che corrispondono unicamente alla sottoespressione. Per impostazione predefinita, se una corrispondenza ha esito negativo, il backtracking ricerca altre possibili corrispondenze. Se si è certi che il backtracking non potrà avere esito positivo, è possibile utilizzare una sottoespressione che non esegue il backtracking per evitare ricerche inutili e migliorare le prestazioni.

Analogamente alle acquisizioni non denominate, le acquisizioni denominate sono numerate in modo sequenziale, in base all'ordine da sinistra a destra della parentesi di apertura, ma la numerazione delle acquisizioni denominate inizia solo dopo il termine del conteggio di tutte le acquisizioni non denominate. Il modello ((?<One>abc)\d+)?(?<Two>xyz)(.*) ad esempio produce i seguenti gruppi di acquisizione in base a numero e nome. La prima acquisizione (numero 0) fa sempre riferimento all'intero criterio.

Numero	Nome	Criterio
0	0 (nome predefinito)	((?<One>abc)\d+)?(?<Two>xyz)(.*)
1	1 (nome predefinito)	((?<One>abc)\d+)
2	2 (nome predefinito)	(.*)
3	One	(?<One>abc)
4	Two	(?<Two>xyz)

Esempio di definizione di gruppo di bilanciamento

Nell'esempio di codice riportato di seguito viene descritto l'utilizzo di una definizione di gruppo di bilanciamento per trovare una corrispondenza di parentesi angolari (< >) sinistre e destre in una stringa di input. Gli insiemi di acquisizioni dei gruppi Open e Close nell'esempio vengono utilizzati come uno stack per tenere traccia delle coppie corrispondenti di parentesi angolari: ogni parentesi angolare sinistra acquisita viene inserita nell'insieme di acquisizioni del gruppo Open, mente ogni parentesi angolare destra acquisita viene inserita nell'insieme di acquisizioni del gruppo Close. La definizione del gruppo di bilanciamento garantisce la corrispondenza tra parentesi angolari destre e parentesi angolari sinistre.

' This code example demonstrates using the balancing group definition feature of 
' regular expressions to match balanced left angle bracket (<) and right angle 
' bracket (>) characters in a string. 

Imports System
Imports System.Text.RegularExpressions

Class Sample
    Public Shared Sub Main() 
'
'    The following expression matches all balanced left and right angle brackets(<>). 
'    The expression:
'    1)   Matches and discards zero or more non-angle bracket characters.
'    2)   Matches zero or more of:
'    2a)  One or more of:
'    2a1) A group named "Open" that matches a left angle bracket, followed by zero 
'         or more non-angle bracket characters. 
'         "Open" essentially counts the number of left angle brackets.
'    2b) One or more of:
'    2b1) A balancing group named "Close" that matches a right angle bracket, 
'         followed by zero or more non-angle bracket characters. 
'         "Close" essentially counts the number of right angle brackets.
'    3)   If the "Open" group contains an unaccounted for left angle bracket, the 
'        entire regular expression fails.
'
        Dim pattern As String = "^[^<>]*" & _
                                "(" + "((?'Open'<)[^<>]*)+" & _
                                "((?'Close-Open'>)[^<>]*)+" + ")*" & _
                                "(?(Open)(?!))$"
        Dim input As String = "<abc><mno<xyz>>"
'
        Dim m As Match = Regex.Match(input, pattern)
        If m.Success = True Then
            Console.WriteLine("Input: ""{0}"" " & vbCrLf & "Match: ""{1}""", _
                               input, m)
        Else
            Console.WriteLine("Match failed.")
        End If
    End Sub 'Main
End Class 'Sample 

'This code example produces the following results:
'
'Input: "<abc><mno<xyz>>"
'Match: "<abc><mno<xyz>>"
'

// This code example demonstrates using the balancing group definition feature of 
// regular expressions to match balanced left angle bracket (<) and right angle 
// bracket (>) characters in a string. 

using System;
using System.Text.RegularExpressions;

class Sample 
{
    public static void Main() 
    {
/*
    The following expression matches all balanced left and right angle brackets(<>). 
    The expression:
    1)   Matches and discards zero or more non-angle bracket characters.
    2)   Matches zero or more of:
    2a)  One or more of:
    2a1) A group named "Open" that matches a left angle bracket, followed by zero 
         or more non-angle bracket characters. 
         "Open" essentially counts the number of left angle brackets.
    2b) One or more of:
    2b1) A balancing group named "Close" that matches a right angle bracket, 
         followed by zero or more non-angle bracket characters. 
         "Close" essentially counts the number of right angle brackets.
    3)   If the "Open" group contains an unaccounted for left angle bracket, the 
        entire regular expression fails.
*/
    string pattern = "^[^<>]*" +
                     "(" + 
                       "((?'Open'<)[^<>]*)+" +
                       "((?'Close-Open'>)[^<>]*)+" +
                     ")*" +
                     "(?(Open)(?!))$";
    string input = "<abc><mno<xyz>>";
//
    Match m = Regex.Match(input, pattern);
    if (m.Success == true)
        Console.WriteLine("Input: \"{0}\" \nMatch: \"{1}\"", input, m);
    else
        Console.WriteLine("Match failed.");
    }
}

/*
This code example produces the following results:

Input: "<abc><mno<xyz>>"
Match: "<abc><mno<xyz>>"

*/

Vedere anche

Altre risorse

Elementi del linguaggio di espressioni regolari