Condividi tramite

Costrutti di raggruppamento

  • Articolo

I costrutti di raggruppamento delineano le sottoespressioni di un'espressione regolare e acquisiscono le sottostringhe di una stringa di input. È possibile utilizzare i costrutti di raggruppamento per effettuare le seguenti operazioni:

  • Trovare la corrispondenza di una sottoespressione ripetuta nella stringa di input.

  • Applicare un quantificatore a una sottoespressione che dispone di più elementi del linguaggio di espressioni regolari. Per ulteriori informazioni sui quantificatori, vedere Quantificatori.

  • Include una sottoespressione nella stringa restituita dai metodi Regex.Replace e Match.Result.

  • Recuperare le sottoespressioni singole dalla proprietà Match.Groups ed elaborarle separatamente dal testo corrispondente nel suo complesso.

.NET Framework supporta i seguenti costrutti di raggruppamento delle espressioni regolari:

  • Sottoespressioni corrispondenti

  • Sottoespressioni corrispondenti denominate

  • Definizioni di gruppo di bilanciamento

  • Gruppo di non acquisizione

  • Opzioni di gruppo

  • Asserzioni lookahead positive di larghezza zero

  • Asserzioni lookahead negative di larghezza zero

  • Asserzioni lookbehind positive di larghezza zero

  • Asserzioni lookbehind negative di larghezza zero

  • Sottoespressione non di backtracking

  • Costrutti di raggruppamento e oggetti di espressione regolare

Sottoespressioni corrispondenti

Nel seguente costrutto di raggruppamento viene acquisita una sottoespressione corrispondente:

( sottoespressione )

dove subexpression è qualsiasi modello di espressione regolare valida. Acquisisce che le parentesi di utilizzo sono numerate automaticamente da sinistra verso destra in base all'ordine delle parentesi di apertura nell'espressione regolare, a partire da uno. L'acquisizione che viene numerata zero è il testo corrispondente all'intero criterio dell'espressione regolare.

NotaNota

Se il parametro RegexOptions di un metodo corrispondente al criterio di espressione regolare include il contrassegno RegexOptions.ExplicitCapture o se l'opzione n viene applicata a questa sottoespressione (vedere Opzioni gruppo più avanti in questo argomento), la sottoespressione corrispondente non viene acquisita.

È possibile accedere a questi gruppi acquisiti in quattro modi diversi:

  • Tramite il costrutto del backreference all'interno dell'espressione regolare. Si fa riferimento alla sottoespressione corrispondente nella stessa espressione regolare tramite la sintassi \number, dove number è il numero ordinale della sottoespressione acquisita.

  • Tramite il costrutto del backreference denominato all'interno dell'espressione regolare. Si fa riferimento alla sottoespressione corrispondente nella stessa espressione regolare tramite la sintassi \k<number>, dove number è il numero ordinale della sottoespressione acquisita. La sottoespressione acquisita dispone di un nome predefinito che è identico al numero ordinale. Per ulteriori informazioni, vedere Sottoespressioni corrispondenti denominate più avanti in questo argomento.

  • Tramite la sequenza di sostituzione $number in Regex.Replace o la chiamata del metodo Match.Result, dove number è il numero ordinale della sottoespressione acquisita.

  • A livello di codice, utilizzando l'oggetto GroupCollection restituito dalla proprietà Match.Groups. Il membro alla posizione zero nell'insieme rappresenta l'intera corrispondenza dell'espressione regolare. Ogni membro successivo rappresenta una sottoespressione corrispondente. Per ulteriori informazioni, vedere la sezione Costrutti di raggruppamento e oggetti di espressione regolare.

Il seguente esempio illustra un'espressione regolare che identifica le parole duplicate in un testo. I due gruppi di acquisizione del criterio dell'espressione regolare rappresentano le due istanze della parola duplicata. La seconda istanza è acquisita per riportare la posizione iniziale nella stringa di input.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\w+)\s(\1)\W"
      Dim input As String = "He said that that was the the correct answer."
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("Duplicate '{0}' found at positions {1} and {2}.", _
                           match.Groups(1).Value, match.Groups(1).Index, match.Groups(2).Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Duplicate 'that' found at positions 8 and 13.
'       Duplicate 'the' found at positions 22 and 26.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w+)\s(\1)";
      string input = "He said that that was the the correct answer.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("Duplicate '{0}' found at positions {1} and {2}.", 
                           match.Groups[1].Value, match.Groups[1].Index, match.Groups[2].Index);
   }
}
// The example displays the following output:
//       Duplicate 'that' found at positions 8 and 13.
//       Duplicate 'the' found at positions 22 and 26.

Il modello dell'espressione regolare è il seguente:

(\w+)\s(\1)\W

Nella tabella seguente viene illustrato come viene interpretato il modello di espressione regolare.

Modello

Oggetto di descrizione

(\w+)

Trovare la corrispondenza di uno o più caratteri alfanumerici. Equivale al primo gruppo di acquisizione.

\s

Trovare la corrispondenza di uno spazio vuoto.

(\1)

Trovare la corrispondenza della stringa nel primo gruppo acquisito. Equivale al secondo gruppo di acquisizione. L'esempio lo assegna a un gruppo acquisito in modo che è possibile recuperare la posizione iniziale della parola duplicata dalla proprietà Match.Index.

\W

Trovare la corrispondenza di un carattere non alfanumerico, inclusi spazio vuoto e punteggiatura. Non consente la corrispondenza di una parola che inizia con la parola dal primo gruppo acquisito da parte del criterio di espressione regolare.

Sottoespressioni corrispondenti denominate

Il seguente costrutto di raggruppamento acquisisce una sottoespressione corrispondente e consente di accedervi tramite nome o numero:

(?<name>subexpression)

oppure:

(?'name' subexpression)

dove name è un nome del gruppo valido e subexpression è qualsiasi modello di espressione regolare valido. name non deve contenere alcun carattere di punteggiatura e non può iniziare con un numero.

NotaNota

Se il parametro RegexOptions di un metodo corrispondente al criterio di espressione regolare include il contrassegno RegexOptions.ExplicitCapture o se l'opzione n viene applicata a questa sottoespressione (vedere Opzioni gruppo più avanti in questo argomento), l'unico modo per acquisire una sottoespressione è di assegnare esplicitamente un nome ai gruppi di acquisizione.

È possibile accedere ai gruppi acquisiti denominati nei seguenti modi:

  • Tramite il costrutto del backreference denominato all'interno dell'espressione regolare. Si fa riferimento alla sottoespressione corrispondente nella stessa espressione regolare tramite la sintassi \k<name>, dove name è il nome della sottoespressione acquisita.

  • Tramite il costrutto del backreference all'interno dell'espressione regolare. Si fa riferimento alla sottoespressione corrispondente nella stessa espressione regolare tramite la sintassi \number, dove number è il numero ordinale della sottoespressione acquisita. Sottoespressioni corrispondenti denominate sono numerate consecutivamente da sinistra a destra dopo le sottoespressioni corrispondenti.

  • Tramite la sequenza di sostituzione ${name} in Regex.Replace o chiamata del metodo Match.Result, dove name è il nome della sottoespressione acquisita .

  • Tramite la sequenza di sostituzione $number> in Regex.Replace o la chiamata del metodo Match.Result, dove number è il numero ordinale della sottoespressione acquisita.

  • A livello di codice, utilizzando l'oggetto GroupCollection restituito dalla proprietà Match.Groups. Il membro alla posizione zero nell'insieme rappresenta l'intera corrispondenza dell'espressione regolare. Ogni membro successivo rappresenta una sottoespressione corrispondente. Gruppi acquisiti denominati vengono archiviati nell'insieme dopo i gruppi acquisiti numerati.

  • A livello di codice, fornendo il nome della sottoespressione all'GroupCollection indicizzatore dell'oggetto (in C#) o alla proprietà Item (in Visual Basic).

Un criterio di espressione regolare semplice illustra in che modo è possibile fare riferimento a gruppi denominati e numerati (non denominati) a livello di codice o tramite sintassi del linguaggio delle espressioni regolari. L'espressione regolare ((?<One>abc)\d+)?(?<Two>xyz)(.*) ad esempio produce i seguenti gruppi di acquisizione in base a numero e nome. Il primo gruppo di acquisizione (numero 0) fa sempre riferimento all'intero criterio.

Numero

Nome

Modello

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)

Nell'esempio seguente viene illustrata un'espressione regolare che identifica parole duplicate e la parola che segue immediatamente ogni parola duplicata. Il criterio di espressione regolare definisce due sottoespressioni denominate: duplicateWord che rappresenta la parola duplicata; e nextWord che rappresenta la parola che segue la parola duplicata.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)"
      Dim input As String = "He said that that was the the correct answer."
      Console.WriteLine(Regex.Matches(input, pattern, RegexOptions.IgnoreCase).Count)
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("A duplicate '{0}' at position {1} is followed by '{2}'.", _
                           match.Groups("duplicateWord").Value, match.Groups("duplicateWord").Index, _
                           match.Groups("nextWord").Value)
      Next
   End Sub
End Module
' The example displays the following output:
'    A duplicate 'that' at position 8 is followed by 'was'.
'    A duplicate 'the' at position 22 is followed by 'correct'.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)";
      string input = "He said that that was the the correct answer.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("A duplicate '{0}' at position {1} is followed by '{2}'.", 
                           match.Groups["duplicateWord"].Value, match.Groups["duplicateWord"].Index, 
                           match.Groups["nextWord"].Value);

   }
}
// The example displays the following output:
//       A duplicate 'that' at position 8 is followed by 'was'.
//       A duplicate 'the' at position 22 is followed by 'correct'.

Il modello dell'espressione regolare è il seguente:

(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)

Nella tabella seguente viene illustrato come viene interpretata l'espressione regolare.

Modello

Oggetto di descrizione

(?<duplicateWord>\w+)

Trovare la corrispondenza di uno o più caratteri alfanumerici. Assegnare al gruppo di acquisizione il nome duplicateWord.

\s

Trovare la corrispondenza di uno spazio vuoto.

\k<duplicateWord>

Trovare la corrispondenza dal gruppo acquisito denominato duplicateWord.

\W

Trovare la corrispondenza di un carattere non alfanumerico, inclusi spazio vuoto e punteggiatura. Non consente la corrispondenza di una parola che inizia con la parola dal primo gruppo acquisito da parte del criterio di espressione regolare.

(?<nextWord>\w+)

Trovare la corrispondenza di uno o più caratteri alfanumerici. Assegnare al gruppo di acquisizione il nome nextWord.

Definizioni di Gruppo di bilanciamento.

Una definizione di gruppo di bilanciamento elimina la definizione di un gruppo precedentemente definito e archivia nel gruppo corrente l'intervallo tra il gruppo precedentemente definito e il gruppo corrente. Questo costrutto di raggruppamento ha il seguente formato:

(?<name1-name2>subexpression)

oppure:

(?'name1-name2' subexpression)

dove name1 è il gruppo corrente (facoltativo), name2 è un gruppo precedentemente definito e la subexpression è qualsiasi modello di espressione regolare valido. La definizione del gruppo di bilanciamento elimina la definizione di name2 e archivia l'intervallo tra name2 e name1 in name1. 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 annidati, come ad esempio le parentesi o le parentesi quadre di apertura e chiusura.

La definizione del gruppo di bilanciamento utilizza name2 come uno stack. Il carattere iniziale di ogni costrutto annidato viene posizionato nel gruppo e nell'insieme Group.Captures. Quando l'ultimo carattere è corrisposto, il carattere di apertura corrispondente viene rimosso dal gruppo e l'insieme Captures viene ridotto di uno. Dopo che i caratteri di apertura e chiusura di tutti i costrutti annidati hanno trovato la corrispondenza, name1 è vuoto.

NotaNota

Dopo avere modificato l'espressione regolare nel seguente esempio per utilizzare il carattere adatto di apertura e chiusura di un costrutto annidato, è possibile utilizzarlo per gestire più costrutti annidati, come ad esempio espressioni matematiche o righe di codice del programma che includono più chiamate al metodo annidate.

Nell'esempio riportato di seguito viene utilizzata una definizione di gruppo di bilanciamento per trovare una corrispondenza di parentesi uncinate aperte e chiuse (<>) in una stringa di input. Nell'esempio vengono definiti due gruppi denominati, Open e Close, utilizzati come uno stack per rilevare coppie corrispondenti di parentesi uncinate. Ogni parentesi uncinata aperta acquisita viene indirizzata nell'insieme di acquisizioni del gruppo Open e ogni parentesi uncinata chiusa acquisita viene indirizzata nell'insieme di acquisizioni del gruppo Close. La definizione di gruppo di bilanciamento si assicura che c'è una parentesi uncinata di chiusura corrispondente per ogni parentesi uncinata di apertura. Se non c'è, il criterio secondario (?(Open)(?!))viene valutato solo se il gruppo Open non è vuoto (e, pertanto, se tutti i costrutti annidati non sono stati chiusi). Se viene valutato il criterio secondario finale, la corrispondenza non riesce, perché la stringa di input non deve contenere alcuna occorrenza di sottostringa ?!.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main() 
        Dim pattern As String = "^[^<>]*" & _
                                "(" + "((?'Open'<)[^<>]*)+" & _
                                "((?'Close-Open'>)[^<>]*)+" + ")*" & _
                                "(?(Open)(?!))$"
        Dim input As String = "<abc><mno<xyz>>"
        Dim rgx AS New Regex(pattern)'
        Dim m As Match = Regex.Match(input, pattern)
        If m.Success Then
            Console.WriteLine("Input: ""{0}"" " & vbCrLf & "Match: ""{1}""", _
                               input, m)
            Dim grpCtr As Integer = 0
            For Each grp As Group In m.Groups
               Console.WriteLine("   Group {0}: {1}", grpCtr, grp.Value)
               grpCtr += 1
               Dim capCtr As Integer = 0
               For Each cap As Capture In grp.Captures            
                  Console.WriteLine("      Capture {0}: {1}", capCtr, cap.Value)
                  capCtr += 1
               Next
            Next
        Else
            Console.WriteLine("Match failed.")
        End If
    End Sub
End Module  
' The example displays the following output:
'       Input: "<abc><mno<xyz>>"
'       Match: "<abc><mno<xyz>>"
'          Group 0: <abc><mno<xyz>>
'             Capture 0: <abc><mno<xyz>>
'          Group 1: <mno<xyz>>
'             Capture 0: <abc>
'             Capture 1: <mno<xyz>>
'          Group 2: <xyz
'             Capture 0: <abc
'             Capture 1: <mno
'             Capture 2: <xyz
'          Group 3: >
'             Capture 0: >
'             Capture 1: >
'             Capture 2: >
'          Group 4:
'          Group 5: mno<xyz>
'             Capture 0: abc
'             Capture 1: xyz
'             Capture 2: mno<xyz>

using System;
using System.Text.RegularExpressions;

class Example
{
   public static void Main() 
   {
      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);
         int grpCtr = 0;
         foreach (Group grp in m.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", grpCtr, grp.Value);
            grpCtr++;
            int capCtr = 0;
            foreach (Capture cap in grp.Captures)
            {            
                Console.WriteLine("      Capture {0}: {1}", capCtr, cap.Value);
                capCtr++;
            }
          }
      }
      else
      {
         Console.WriteLine("Match failed.");
      }   
    }
}
// The example displays the following output:
//    Input: "<abc><mno<xyz>>"
//    Match: "<abc><mno<xyz>>"
//       Group 0: <abc><mno<xyz>>
//          Capture 0: <abc><mno<xyz>>
//       Group 1: <mno<xyz>>
//          Capture 0: <abc>
//          Capture 1: <mno<xyz>>
//       Group 2: <xyz
//          Capture 0: <abc
//          Capture 1: <mno
//          Capture 2: <xyz
//       Group 3: >
//          Capture 0: >
//          Capture 1: >
//          Capture 2: >
//       Group 4:
//       Group 5: mno<xyz>
//          Capture 0: abc
//          Capture 1: xyz
//          Capture 2: mno<xyz>

Il modello di espressione regolare è:

^[^<>]*(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)*(?(Open)(?!))$

L'espressione regolare viene interpretata come segue:

Modello

Oggetto di descrizione

^

Iniziare all'inizio della stringa.

[^<>]*

Trovare la corrispondenza di zero o più caratteri che non siano parentesi uncinate aperte o chiuse.

(?'Open'<)

Trovare la corrispondenza di una parentesi uncinata aperta e assegnarla a un gruppo denominato Open.

[^<>]*

Trovare la corrispondenza di zero o più caratteri che non siano parentesi uncinate aperte o chiuse.

((?'Open'<)[^<>]*) +

Trovare la corrispondenza di una o più occorrenze di una parentesi uncinata aperta seguita da zero o più caratteri che non siano parentesi uncinate aperte o chiuse. Equivale al secondo gruppo di acquisizione.

(?'Close-Open'>)

Trovare la corrispondenza di una parentesi uncinata chiusa, assegnare la sottostringa tra il gruppo Open e il gruppo corrente Close ed eliminare la definizione del gruppo Open.

[^<>]*

Trovare la corrispondenza di uno zero o più occorrenze di un qualsiasi carattere che non sia nè una parentesi uncinata aperta nè una parentesi uncinata chiusa.

((?'Close-Open'>)[^<>]*)+

Trovare la corrispondenza di una o più occorrenze di una parentesi uncinata chiusa, seguita da zero o più occorrenze di qualsiasi carattere che non sia nè una parentesi uncinata aperta né una parentesi uncinata chiusa. In caso di corrispondenza di una parentesi uncinata chiusa, assegnare la sottostringa tra il gruppo Open e il gruppo corrente Close ed eliminare la definizione del gruppo Open. Equivale al terzo gruppo di acquisizione.

(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)*

Trovare la corrispondenza di uno zero o più occorrenze del seguente modello: una o più occorrenze di una parentesi uncinata aperta, seguita da zero o più parentesi non uncinate, seguite da una o più occorrenze di una parentesi uncinata chiusa, seguita da zero o più occorrenze di parentesi non uncinate. In caso di corrispondenza di una parentesi uncinata chiusa, eliminare la definizione del gruppo Open e assegnare la sottostringa tra il gruppo Open e il gruppo corrente al gruppo Close. Equivale al primo gruppo di acquisizione.

(?(Open)(?!))

Se il gruppo Open esiste, mettere in corrispondenza un punto interrogativo e un punto esclamativo. Se il gruppo Open è definito, la corrispondenza non riesce, il che indica che le parentesi uncinate non sono bilanciate.

$

Corrisponde alla fine della stringa di input.

La sottoespressione finale, (?(Open)(?!)) indica se i costrutti annidati nella stringa di input sono bilanciati correttamente (ad esempio, se ad ogni parentesi uncinata aperta corrisponde una parentesi uncinata chiusa). Utilizza la corrispondenza condizionale basata su un gruppo acquisito valido; per ulteriori informazioni, vedere Costrutti di alternanza. Se il gruppo Open è definito, il motore delle espressioni regolari tenta di mettere in corrispondenza la sottoespressione (?!) nella stringa di input. Il gruppo Open deve essere definito solo se i costrutti in annidamento non sono bilanciati. Pertanto, il criterio di cui trovare la corrispondenza nella stringa di input deve essere un criterio che non può verificarsi nella stringa di input, che genera l'esito negativo della corrispondenza.

Nell'esempio, il motore dell'espressione regolare valuta la stringa di input "<abc><mno<xyz>>", come viene illustrato nella tabella seguente.

Passaggio

Modello

Risultato

1

^

Inizia la corrispondenza all'inizio della stringa di input

2

[^<>]*

Cerca caratteri della parentesi non uncinate prima la parentesi uncinata aperta;non trova corrispondenze.

3

(((?'Open'<)

Trova la corrispondenza della parentesi uncinata aperta in "<abc>" e l'assegna al gruppo Open.

4

[^<>]*

Corrisponde a "abc".

5

)+

"<abc" è il valore del secondo gruppo acquisito.

Il carattere successivo nella stringa di input non è una parentesi uncinata aperta, pertanto il motore delle espressioni regolari non esegue di nuovo il ciclo nel criterio secondario (?'Open'<)[^<>]*).

6

((?'Close-Open'>)

Trova la corrispondenza della parentesi uncinata chiusa in "<abc>", assegna "abc", che è la sottostringa tra il gruppo Open e la parentesi uncinata chiusa, al gruppo Close ed elimina il valore corrente ("<") del gruppo Open, lasciandolo vuoto.

7

[^<>]*

Cerca caratteri della parentesi non uncinate dopo la parentesi uncinata chiusa; non trova corrispondenze.

8

)+

Il valore del terzo gruppo acquisito è ">".

Il carattere successivo nella stringa di input non è una parentesi uncinata chiusa, pertanto il motore delle espressioni regolari è ritornato al criterio secondario ((?'Close-Open'>)[^<>]*).

9

)*

Il valore del primo gruppo acquisito è "<abc>".

Il carattere successivo nella stringa di input è una parentesi uncinata aperta, pertanto il motore delle espressioni regolari è ritornato al criterio secondario (((?'Open'<).

10

(((?'Open'<)

Trova la corrispondenza della parentesi uncinata aperta in "<mno>" e l'assegna al gruppo Open. L'insieme Group.Captures dispone ora di un solo valore, "<".

11

[^<>]*

Corrisponde a "mno".

12

)+

"<mno" è il valore del secondo gruppo acquisito.

Il carattere successivo nella stringa di input è una parentesi uncinata aperta, pertanto il motore delle espressioni regolari è ritornato al criterio secondario (?'Open'<)[^<>]*).

13

(((?'Open'<)

Trova la corrispondenza della parentesi uncinata aperta in "<xyz>" e l'assegna al gruppo Open. L'insieme Group.Captures del gruppo Open include ora due acquisizioni: la parentesi uncinata aperta da "<mno>" e la parentesi uncinata aperta da "<xyz>."

14

[^<>]*

Corrisponde a "xyz".

15

)+

"<xyz" è il valore del secondo gruppo acquisito.

Il carattere successivo nella stringa di input non è una parentesi uncinata aperta, pertanto il motore delle espressioni regolari non esegue di nuovo il ciclo nel criterio secondario (?'Open'<)[^<>]*).

16

((?'Close-Open'>)

Trova la corrispondenza della parentesi uncinata chiusa in "<xyz>". " xyz", assegna la sottostringa tra il gruppo Open e la parentesi uncinata chiusa al gruppo Close ed elimina il valore corrente del gruppo Open. Il valore dell'acquisizione precedente (la parentesi uncinata aperta in "<mno>") diventa il valore corrente del gruppo Open. L'insieme Captures del gruppo Open include ora una sola acquisizione, la parentesi uncinata aperta da "<xyz>."

17

[^<>]*

Cerca caratteri della parentesi non uncinate; non trova corrispondenze.

18

)+

Il valore del terzo gruppo acquisito è ">".

Il carattere successivo nella stringa di input è una parentesi uncinata chiusa, pertanto il motore delle espressioni regolari è ritornato al criterio secondario ((?'Close-Open'>)[^<>]*).

19

((?'Close-Open'>)

Trova la corrispondenza della parentesi uncinata chiusa finale in "xyz>>", assegna "mno<xyz>" (la sottostringa tra il gruppo Open e la parentesi uncinata chiusa) al gruppo Close ed elimina il valore corrente del gruppo Open. Il gruppo Open adesso è vuoto.

20

[^<>]*

Cerca caratteri della parentesi non uncinate; non trova corrispondenze.

21

)+

Il valore del terzo gruppo acquisito è ">".

Il carattere successivo nella stringa di input non è una parentesi uncinata chiusa, pertanto il motore delle espressioni regolari è ritornato al criterio secondario ((?'Close-Open'>)[^<>]*).

22

)*

Il valore del primo gruppo acquisito è "<mno<xyz>>".

Il carattere successivo nella stringa di input non è una parentesi uncinata aperta, pertanto il motore delle espressioni regolari non esegue di nuovo il ciclo nel criterio secondario (((?'Open'<).

23

(?(Open)(?!))

Il gruppo Open non è definito, pertanto non viene eseguita alcuna corrispondenza.

24

$

Trova la corrispondenza della fine della stringa di input.

Gruppo di non acquisizione

Nel seguente costrutto di raggruppamento non viene acquisita la sottostringa corrisposta da una sottoespressione:

(?:subexpression)

dove subexpression è qualsiasi modello di espressione regolare valida. Il costrutto del gruppo non di acquisizione viene utilizzato in genere quando un quantificatore è applicato a un gruppo, ma le sottostringhe acquisite dal gruppo non sono di alcun interesse.

NotaNota

Se un'espressione regolare include costrutti di raggruppamento annidati, un costrutto non acquisito esterno non si applica ai costrutti del gruppo annidati interni.

Nell'esempio seguente viene illustrata un'espressione regolare che include gruppi di non acquisizione. Notare che l'output non include alcun gruppo acquisito.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?:\b(?:\w+)\W*)+\."
      Dim input As String = "This is a short sentence."
      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: {0}", match.Value)
      For ctr As Integer = 1 To match.Groups.Count - 1
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       Match: This is a short sentence.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?:\b(?:\w+)\W*)+\.";
      string input = "This is a short sentence.";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: {0}", match.Value);
      for (int ctr = 1; ctr < match.Groups.Count; ctr++)
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
   }
}
// The example displays the following output:
//       Match: This is a short sentence.

L'espressione regolare (?:\b(?:\w+)\W*)+\. corrisponde a una frase che termina con un punto. Poiché l'espressione regolare si concentra sulle frasi e non sulle singole parole, i costrutti di raggruppamento vengono utilizzati esclusivamente come quantificatori. Il modello dell'espressione regolare viene interpretato come illustrato nella tabella seguente.

Modello

Oggetto di descrizione

\b

Inizia la corrispondenza sul confine di parola.

(?:\w+)

Trovare la corrispondenza di uno o più caratteri alfanumerici. Non assegnare il testo corrispondente a un gruppo acquisito.

\W*

Corrisponde a zero o più caratteri non alfanumerici.

(?:\b(?:\w+)\W*)+

Trovare la corrispondenza con il modello di uno o più caratteri alfanumerici a partire dal confine di una parola, seguiti da zero o più caratteri non alfanumerici, una o più volte. Non assegnare il testo corrispondente a un gruppo acquisito.

\.

Corrisponde a un punto.

Opzioni di gruppo

Il seguente costrutto di raggruppamento applica o disabilita le opzioni specificate in una sottoespressione:

(?imnsx-imnsx: sottoespressione )

dove subexpression è qualsiasi modello di espressione regolare valida. Ad esempio, (?i-s:) attiva la modalità di non distinzione tra maiuscole e minuscole e disabilita la modalità a riga singola. Per ulteriori informazioni sulle opzioni inline che è possibile specificare, vedere Opzioni di espressioni regolari.

NotaNota

È possibile specificare opzioni che si applicano a un'espressione regolare intera piuttosto che una sottoespressione tramite un costruttore di classe System.Text.RegularExpressions.Regex o un metodo statico.È possibile specificare anche opzioni inline che si applicano dopo un punto specifico in un'espressione regolare tramite il costrutto di linguaggio (?imnsx-imnsx).

Il costrutto delle opzioni di gruppo non è un gruppo di acquisizione. Ovvero, sebbene qualsiasi parte di una stringa acquisita dalla sottoespressione è inclusa nella corrispondenza, non viene inclusa in un gruppo acquisito né utilizzato per popolare l'oggetto GroupCollection.

Ad esempio, l'espressione regolare \b(?ix: d \w+)\s nell'esempio seguente utilizza opzioni inline in un costrutto di raggruppamento per abilitare la corrispondenza senza distinzione tra maiuscole e minuscole e ignorare lo spazio vuoto del modello nell'identificazione di tutte le parole che iniziano con la lettera "d." L'espressione regolare viene definita come illustrato nella tabella seguente.

Modello

Oggetto di descrizione

\b

Inizia la corrispondenza sul confine di parola.

(?ix: d \w+)

L'utilizzo della corrispondenza senza distinzione tra maiuscole e minuscole e ignorando lo spazio vuoto in questo modello, stabilisce la corrispondenza di una "d" seguita da uno o più caratteri alfanumerici.

\s

Trovare la corrispondenza di uno spazio vuoto.

 
Dim pattern As String = "\b(?ix: d \w+)\s"
Dim input As String = "Dogs are decidedly good pets."

For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.      

string pattern = @"\b(?ix: d \w+)\s";
string input = "Dogs are decidedly good pets.";

foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.

Asserzione lookahead positiva di larghezza zero

Nel seguente costrutto di raggruppamento viene definita un'asserzione di lookahead positiva di larghezza zero:

(?= sottoespressione )

dove subexpression è qualsiasi modello di espressione regolare. Affinché una corrispondenza abbia successo, la stringa di input deve corrispondere al modello di espressione regolare nella sottoespressione, sebbene la sottoespressione non è inclusa nel risultato della corrisp‬ondenza. Asserzione lookahead positiva di larghezza zero non esegue il backtracking.

In genere, un'asserzione lookahead positiva di larghezza zero viene trovata alla fine di un criterio di espressione regolare. Definisce una sottostringa che deve essere trovata alla fine di una stringa affinché si verifichi una corrispondenza ma che non deve essere inclusa nella corrispondenza. È inoltre utile per impedire un backtracking eccessivo. È possibile utilizzare un'asserzione lookahead positiva di larghezza zero per assicurarsi che un particolare gruppo acquisito inizi con il testo che corrisponde a un subset del modello definito per tale gruppo acquisito. Se, ad esempio, un gruppo di acquisizione corrisponde a caratteri alfanumerici consecutivi, è possibile utilizzare un'asserzione positiva lookahead di larghezza zero per richiedere che il primo carattere sia un carattere alfabetico maiuscolo.

Nell'esempio seguente viene utilizzata un'asserzione lookahead positiva di larghezza zero per corrispondere la parola che precede il verbo "is" nella stringa di input.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+(?=\sis\b)"
      Dim inputs() As String = { "The dog is a Malamute.", _
                                 "The island has beautiful birds.", _
                                 "The pitch missed home plate.", _
                                 "Sunday is a weekend day." }

      For Each input As String In inputs
         Dim match As Match = Regex.Match(input, pattern)
         If match.Success Then
            Console.WriteLine("'{0}' precedes 'is'.", match.Value)
         Else
            Console.WriteLine("'{0}' does not match the pattern.", input) 
         End If     
      Next
   End Sub
End Module
' The example displays the following output:
'       'dog' precedes 'is'.
'       'The island has beautiful birds.' does not match the pattern.
'       'The pitch missed home plate.' does not match the pattern.
'       'Sunday' precedes 'is'.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+(?=\sis\b)";
      string[] inputs = { "The dog is a Malamute.", 
                          "The island has beautiful birds.", 
                          "The pitch missed home plate.", 
                          "Sunday is a weekend day." };

      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern);
         if (match.Success)
            Console.WriteLine("'{0}' precedes 'is'.", match.Value);
         else
            Console.WriteLine("'{0}' does not match the pattern.", input); 
      }
   }
}
// The example displays the following output:
//    'dog' precedes 'is'.
//    'The island has beautiful birds.' does not match the pattern.
//    'The pitch missed home plate.' does not match the pattern.
//    'Sunday' precedes 'is'.

L'espressione regolare \b\w+(?=\sis\b) viene interpretata come illustrato nella tabella seguente.

Modello

Oggetto di descrizione

\b

Inizia la corrispondenza sul confine di parola.

\w+

Trovare la corrispondenza di uno o più caratteri alfanumerici.

(?=\sis\b)

Determinare se i caratteri alfanumerici vengono seguiti da uno spazio vuoto e dalla stringa "is", che termina su un confine di parola. In tal caso, la corrispondenza è valida.

Asserzione lookahead negativa di larghezza zero

Nel seguente costrutto di raggruppamento viene definita un'asserzione di lookahead negativa di larghezza:

(?! sottoespressione )

dove subexpression è qualsiasi modello di espressione regolare. Affinché una corrispondenza abbia successo, la stringa di input non deve corrispondere al modello di espressione regolare nella sottoespressione, sebbene la stringa corrispondente non è inclusa nel risultato della corrisp‬ondenza.

Un'asserzione lookahead negativa di larghezza zero viene utilizzata in genere all'inizio o alla fine di un'espressione regolare. All'inizio di un'espressione regolare, può definire un modello specifico che non deve avere una corrispondenza quando l'inizio dell'espressione regolare definisce un modello simile ma più generale da corrispondere. In questo caso, viene spesso utilizzata per limitare il backtracking. Alla fine di un'espressione regolare, può definire una sottoespressione che non può verificarsi alla fine di una corrispondenza.

Nell'esempio seguente viene definita un'espressione regolare che utilizza un'asserzione lookahead di larghezza zero all'inizio dell'espressione regolare per corrispondere parole che non iniziano con "un".

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(?!un)\w+\b"
      Dim input As String = "unite one unethical ethics use untie ultimate"
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       one
'       ethics
'       use
'       ultimate

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(?!un)\w+\b";
      string input = "unite one unethical ethics use untie ultimate";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       one
//       ethics
//       use
//       ultimate

L'espressione regolare \b(?!un)\w+\b viene interpretata come illustrato nella tabella seguente.

Modello

Oggetto di descrizione

\b

Inizia la corrispondenza sul confine di parola.

(?!un)

Determinare se i due caratteri successivi sono "non." Se non ce ne sono, una corrispondenza è possibile.

\w+

Trovare la corrispondenza di uno o più caratteri alfanumerici.

\b

Termina la corrispondenza sul confine di parola.

Nell'esempio seguente viene definita un'espressione regolare che utilizza un'asserzione lookahead di larghezza zero alla fine dell'espressione regolare per corrispondere parole che non terminano con un carattere di punteggiatura.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+\b(?!\p{P})"
      Dim input As String = "Disconnected, disjointed thoughts in a sentence fragment."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next   
   End Sub
End Module
' The example displays the following output:
'       disjointed
'       thoughts
'       in
'       a
'       sentence

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+\b(?!\p{P})";
      string input = "Disconnected, disjointed thoughts in a sentence fragment.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       disjointed
//       thoughts
//       in
//       a
//       sentence

L'espressione regolare \b\w+\b(?!\p{P}) viene interpretata come illustrato nella tabella seguente.

Modello

Oggetto di descrizione

\b

Inizia la corrispondenza sul confine di parola.

\w+

Trovare la corrispondenza di uno o più caratteri alfanumerici.

\b

Termina la corrispondenza sul confine di parola.

\p{P})

Se il carattere successivo non è un simbolo di punteggiatura (quale un punto o una virgola), la corrispondenza riesce.

Asserzione lookbehind positiva di larghezza zero

Nel seguente costrutto di raggruppamento viene definita un'asserzione di lookabehind positiva di larghezza zero:

(?<= sottoespressione )

dove subexpression è qualsiasi modello di espressione regolare. Affinché una corrispondenza abbia successo, la sottoespressione deve verificarsi sulla stringa di input a sinistra della posizione corrente, sebbene subexpression non è inclusa nel risultato della corrisp‬ondenza. Asserzione lookbehind positiva di larghezza zero non esegue il backtracking.

Asserzioni lookbehind positive di larghezza zero vengono utilizzate in genere all'inizio delle espressioni regolari. Il modello definito è una precondizione per una corrispondenza, anche se non è una parte del risultato della corrispondenza.

Ad esempio, nell'esempio seguente vengono messe in corrispondenza le ultime due cifre dell'anno per il ventunesimo secolo ovvero, richiede che la cifra "20" preceda la stringa corrispondente).

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "2010 1999 1861 2140 2009"
      Dim pattern As String = "(?<=\b20)\d{2}\b"

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next      
   End Sub
End Module
' The example displays the following output:
'       10
'       09

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "2010 1999 1861 2140 2009";
      string pattern = @"(?<=\b20)\d{2}\b";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       10
//       09

Il modello di espressione regolare (?<=\b20)\d{2}\b viene interpretato come illustrato nella tabella seguente.

Modello

Oggetto di descrizione

\d{2}

Corrisponde a due cifre decimali.

{?<=\b20)

Continuare la corrispondenza se le due cifre decimali vengono precedute dalle cifre decimali "20" su un confine di parola.

\b

Termina la corrispondenza sul confine di parola.

Le asserzioni lookbehind positive di larghezza zero vengono utilizzate anche per limitare il backtracking quando l'ultimo carattere o gli ultimi caratteri di un gruppo acquisito devono essere rappresentati da un subset di caratteri corrispondenti al modello di espressione regolare di tale gruppo. Se, ad esempio, un gruppo acquisisce tutti i caratteri alfanumerici consecutivi, è possibile utilizzare un'asserzione positiva lookbehind di larghezza zero per richiedere che l'ultimo carattere sia un carattere alfabetico.

Asserzioni lookbehind negative di larghezza zero

Nel seguente costrutto di raggruppamento viene definita un'asserzione di lookabehind negativa di larghezza zero:

(?<! sottoespressione )

dove subexpression è qualsiasi modello di espressione regolare. Affinché una corrispondenza abbia successo, non deve verificarsi la sottoespressione sulla stringa di input a sinistra della posizione corrente. Tuttavia, qualsiasi sottostringa che non corrisponde subexpression non viene inclusa nel risultato della corrispondenza.

Asserzioni lookbehind negative di larghezza zero vengono utilizzate in genere all'inizio delle espressioni regolari. Il modello definito preclude una corrispondenza nella stringa che segue. Tali asserzioni vengono utilizzate anche per limitare il backtracking quando l'ultimo carattere o gli ultimi caratteri di un gruppo acquisito non devono essere uno o più caratteri corrispondenti al modello di espressione regolare di tale gruppo. Se, ad esempio, un gruppo acquisisce tutti i caratteri alfanumerici consecutivi, è possibile utilizzare un'asserzione positiva lookbehind di larghezza zero per richiedere che l'ultimo carattere non sia un carattere di sottolineatura (_).

Nell'esempio seguente viene eseguita la corrispondenza della data per qualsiasi giorno della settimana che non è un fine settimana (ovvero, che non è né sabato né domenica).

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim dates() As String = { "Monday February 1, 2010", _
                                "Wednesday February 3, 2010", _
                                "Saturday February 6, 2010", _
                                "Sunday February 7, 2010", _
                                "Monday, February 8, 2010" }
      Dim pattern As String = "(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b"

      For Each dateValue As String In dates
         Dim match As Match = Regex.Match(dateValue, pattern)
         If match.Success Then
            Console.WriteLine(match.Value)
         End If   
      Next      
   End Sub
End Module
' The example displays the following output:
'       February 1, 2010
'       February 3, 2010
'       February 8, 2010

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] dates = { "Monday February 1, 2010", 
                         "Wednesday February 3, 2010", 
                         "Saturday February 6, 2010", 
                         "Sunday February 7, 2010", 
                         "Monday, February 8, 2010" };
      string pattern = @"(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b";

      foreach (string dateValue in dates)
      {
         Match match = Regex.Match(dateValue, pattern);
         if (match.Success)
            Console.WriteLine(match.Value);
      }      
   }
}
// The example displays the following output:
//       February 1, 2010
//       February 3, 2010
//       February 8, 2010

Il modello di espressione regolare (?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b viene interpretato come illustrato nella tabella seguente.

Modello

Oggetto di descrizione

\b

Inizia la corrispondenza sul confine di parola.

\w+

Trovare la corrispondenza di uno o più caratteri seguiti da un carattere diverso da uno spazio vuoto.

\d{1,2},

Trovare la corrispondenza di una o due cifre decimali seguite da uno spazio vuoto e una virgola.

\d{4}\b

Trovare la corrispondenza di quattro cifre decimali e terminare la corrispondenza al confine di una parola.

(?<!(Saturday|Sunday) )

Se la corrispondenza viene preceduta da qualcosa di diverso dalle stringhe "sabato" o "domenica" seguite da uno spazio, la corrispondenza ha successo.

Sottoespressione non di backtracking

Nel seguente costrutto di raggruppamento viene rappresentata una sottoespressione di non backtracking (nota anche come una sottoespressione "greedy"):

(?> sottoespressione )

dove subexpression è qualsiasi modello di espressione regolare.

Ordinariamente, se un'espressione regolare include un modello della corrispondenza facoltativo o alternativo e una corrispondenza non riesce, il motore delle espressioni regolari può creare un ramo in più direzioni per trovare la corrispondenza di una stringa di input con un modello. Se non viene trovata una corrispondenza quando prende il primo ramo, il motore delle espressioni regolari può eseguire il backup o il backtracking al punto in cui ha preso la prima corrispondenza e tenta la corrispondenza utilizzando il secondo ramo. Questo processo può continuare fino a che non sono stati provati tutti i rami.

Il costrutto di linguaggio della ) sottoespressione (?> disabilita il backtracking. Il motore delle espressioni regolari corrisponderà come molti caratteri nella stringa di input come può. Quando non troverà alcuna ulteriore corrispondenza, non tornerà indietro per tentare corrispondenze di criteri alternativi. La sottoespressione corrisponde pertanto a stringhe che corrispondono unicamente alla sottoespressione; non tenta di corrispondere una stringa in base alla sottoespressione e a qualsiasi sottoespressione successiva.

Si consiglia questa opzione se si sa che il backtracking non avrà esito positivo. Impedendo al motore delle espressioni regolari di eseguire ricerche non necessarie, migliora le prestazioni.

L'esempio seguente illustra come una sottoespressione che non esegue il backtracking modifica i risultati di una corrispondenza di criteri. L'espressione regolare di backtracking corrisponde correttamente a una serie di caratteri ripetuti seguiti da una più occorrenze dello stesso carattere su un confine di parola, ma non l'espressione regolare di non esecuzione del backtracking.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "cccd.", "aaad", "aaaa" }
      Dim back As String = "(\w)\1+.\b"
      Dim noback As String = "(?>(\w)\1+).\b"

      For Each input As String In inputs
         Dim match1 As Match = Regex.Match(input, back)
         Dim match2 As Match = Regex.Match(input, noback)
         Console.WriteLine("{0}: ", input)

         Console.Write("   Backtracking : ")
         If match1.Success Then
            Console.WriteLine(match1.Value)
         Else
            Console.WriteLine("No match")
         End If

         Console.Write("   Nonbacktracking: ")
         If match2.Success Then
            Console.WriteLine(match2.Value)
         Else
            Console.WriteLine("No match")
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'    cccd.:
'       Backtracking : cccd
'       Nonbacktracking: cccd
'    aaad:
'       Backtracking : aaad
'       Nonbacktracking: aaad
'    aaaa:
'       Backtracking : aaaa
'       Nonbacktracking: No match

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "cccd.", "aaad", "aaaa" };
      string back = @"(\w)\1+.\b";
      string noback = @"(?>(\w)\1+).\b";

      foreach (string input in inputs)
      {
         Match match1 = Regex.Match(input, back);
         Match match2 = Regex.Match(input, noback);
         Console.WriteLine("{0}: ", input);

         Console.Write("   Backtracking : ");
         if (match1.Success)
            Console.WriteLine(match1.Value);
         else
            Console.WriteLine("No match");

         Console.Write("   Nonbacktracking: ");
         if (match2.Success)
            Console.WriteLine(match2.Value);
         else
            Console.WriteLine("No match");
      }
   }
}
// The example displays the following output:
//    cccd.:
//       Backtracking : cccd
//       Nonbacktracking: cccd
//    aaad:
//       Backtracking : aaad
//       Nonbacktracking: aaad
//    aaaa:
//       Backtracking : aaaa
//       Nonbacktracking: No match

L'espressione regolare (?>(\w)\1+).\b non di backtracking viene definita come illustrato nella tabella seguente.

Modello

Oggetto di descrizione

(\w)

Trovare la corrispondenza di un unico carattere alfanumerico e assegnarlo al primo gruppo di acquisizione.

\1+

Trovare la corrispondenza del valore della prima sottostringa acquisita una o più volte.

.

Trovare la corrispondenza di qualsiasi carattere.

\b

Termina la corrispondenza sul confine di parola.

(?>(\w)\1+)

Trovare la corrispondenza di una o più occorrenze di un carattere alfanumerico duplicato, ma non eseguire il backtracking per trovare la corrispondenza dell'ultimo carattere al confine di una parola.

Costrutti di raggruppamento e oggetti di espressione regolare

Sottostringhe corrisposte da un gruppo di acquisizione dell'espressione regolare vengono rappresentate da oggetti System.Text.RegularExpressions.Group che possono essere recuperati dall'oggetto System.Text.RegularExpressions.GroupCollection restituito dalla proprietà Match.Groups. L'oggetto GroupCollection viene popolato come segue:

  • Il primo oggetto Group nell'insieme (tutti oggetti a zero indice) rappresenta l'intera corrispondenza.

  • Il set successivo di oggetti Group rappresenta gruppi di acquisizione senza nome (numerati). Vengono visualizzate nell'ordine in cui sono definite nell'espressione regolare, da sinistra a destra. I valori di indice di questi gruppi sono compresi tra 1 e un numero di gruppi di acquisizione senza nome nell'insieme. (L'indice di un particolare gruppo è equivalente al backreference numerato. Per ulteriori informazioni sui backreference, vedere Costrutti di backreference.)

  • Il set finale di oggetti Group rappresenta gruppi di acquisizione denominati. Vengono visualizzate nell'ordine in cui sono definite nell'espressione regolare, da sinistra a destra. Il valore di indice del primo gruppo di acquisizione denominato è quello più grande dell'indice dell'ultimo gruppo di acquisizione senza nome. Se non ci sono gruppi di acquisizione senza nome nell'espressione regolare, il valore di indice del primo gruppo di acquisizione denominato è zero.

Se a un gruppo di acquisizione viene applicato un quantificatore, le proprietà Capture.Value, Capture.Index e Capture.Length dell'oggetto corrispondente Group rappresentano l'ultima sottostringa acquisita dal gruppo di acquisizione. È possibile recuperare un set completo di sottostringhe acquisite da gruppi che dispongono di quantificatori dall'oggetto CaptureCollection restituito dalla proprietà Group.Captures.

Nell'esempio seguente viene spiegata la relazione tra gli oggetti Group e Capture.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\b(\w+)\W+)+"
      Dim input As String = "This is a short sentence."
      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: {0}", match.Value)
      For ctr As Integer = 1 To match.Groups.Count - 1
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
         Dim capCtr As Integer = 0
         For Each capture As Capture In match.Groups(ctr).Captures
            Console.WriteLine("      Capture {0}: {1}", capCtr, capture.Value)
            capCtr += 1
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       Match: This is a short sentence.
'          Group 1: sentence.
'             Capture 0: This
'             Capture 1: is
'             Capture 2: a
'             Capture 3: short
'             Capture 4: sentence.
'          Group 2: sentence
'             Capture 0: This
'             Capture 1: is
'             Capture 2: a
'             Capture 3: short
'             Capture 4: sentence

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\b(\w+)\W+)+";
      string input = "This is a short sentence.";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: {0}", match.Value);
      for (int ctr = 1; ctr < match.Groups.Count; ctr++)
      {
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
         int capCtr = 0;
         foreach (Capture capture in match.Groups[ctr].Captures)
         {
            Console.WriteLine("      Capture {0}: {1}", capCtr, capture.Value);
            capCtr++;
         }
      }
   }
}
// The example displays the following output:
//       Match: This is a short sentence.
//          Group 1: sentence.
//             Capture 0: This
//             Capture 1: is
//             Capture 2: a
//             Capture 3: short
//             Capture 4: sentence.
//          Group 2: sentence
//             Capture 0: This
//             Capture 1: is
//             Capture 2: a
//             Capture 3: short
//             Capture 4: sentence

Il criterio dell'espressione regolare \b(\w+)\W+)+ estrae le singole parole da una stringa. Viene definita come mostrato nella tabella seguente:

Modello

Oggetto di descrizione

\b

Inizia la corrispondenza sul confine di parola.

(\w+)

Trovare la corrispondenza di uno o più caratteri alfanumerici. Insieme, questi caratteri formano una parola. Equivale al secondo gruppo di acquisizione.

\W+

Corrisponde a uno o più caratteri non alfanumerici.

(\w+)\W+)+

Trovare la corrispondenza con il modello di uno o più caratteri alfanumerici seguiti da uno o più caratteri non alfanumerici, una o più volte. Equivale al primo gruppo di acquisizione.

Il primo gruppo di acquisizione corrisponde a ogni parola della frase. Il secondo gruppo di acquisizione corrisponde a ogni parola insieme alla punteggiatura e allo spazio vuoto che seguono la parola. L'oggetto Group il cui indice è 2 fornisce informazioni sul testo corrisposto dal secondo gruppo di acquisizione. Il set completo di parole acquisite dal gruppo di acquisizione è disponibile dall'oggetto CaptureCollection restituito dalla proprietà Group.Captures.

Vedere anche

Concetti

Elementi del linguaggio di espressioni regolari

Backtracking