Costrutti di alternanza nelle espressioni regolariAlternation Constructs in Regular Expressions

I costrutti di alternanza modificano un'espressione regolare per abilitare la corrispondenza di tipo either/or o condizionale.Alternation constructs modify a regular expression to enable either/or or conditional matching. .NET supporta tre costrutti di alternanza:.NET supports three alternation constructs:

Criteri di ricerca con |Pattern Matching with |

È possibile usare la barra verticale (|) per trovare la corrispondenza con uno qualsiasi di una serie di criteri, dove i singoli criteri sono separati dal carattere |.You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern.

Analogamente alla classe di caratteri positivi, il carattere | può essere usato per trovare la corrispondenza con uno qualsiasi tra diversi caratteri singoli.Like the positive character class, the | character can be used to match any one of a number of single characters. L'esempio seguente usa sia una classe di caratteri positivi sia criteri di ricerca di tipo either/or con il carattere | per individuare le occorrenze delle parole "gray" o "grey" in una stringa.The following example uses both a positive character class and either/or pattern matching with the | character to locate occurrences of the words "gray" or "grey" in a string. In questo caso, | produce un'espressione regolare più dettagliata.In this case, the | character produces a regular expression that is more verbose.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Regular expression using character class.
      string pattern1 = @"\bgr[ae]y\b";
      // Regular expression using either/or.
      string pattern2 = @"\bgr(a|e)y\b";
      
      string input = "The gray wolf blended in among the grey rocks.";
      foreach (Match match in Regex.Matches(input, pattern1))
         Console.WriteLine("'{0}' found at position {1}", 
                           match.Value, match.Index);
      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, pattern2))
         Console.WriteLine("'{0}' found at position {1}", 
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       'gray' found at position 4
//       'grey' found at position 35
//       
//       'gray' found at position 4
//       'grey' found at position 35           
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Regular expression using character class.
      Dim pattern1 As String = "\bgr[ae]y\b"
      ' Regular expression using either/or.
      Dim pattern2 As String = "\bgr(a|e)y\b"
      
      Dim input As String = "The gray wolf blended in among the grey rocks."
      For Each match As Match In Regex.Matches(input, pattern1)
         Console.WriteLine("'{0}' found at position {1}", _
                           match.Value, match.Index)
      Next      
      Console.WriteLine()
      For Each match As Match In Regex.Matches(input, pattern2)
         Console.WriteLine("'{0}' found at position {1}", _
                           match.Value, match.Index)
      Next      
   End Sub
End Module
' The example displays the following output:
'       'gray' found at position 4
'       'grey' found at position 35
'       
'       'gray' found at position 4
'       'grey' found at position 35           

L'espressione regolare che usa il carattere | , \bgr(a|e)y\b, viene interpretata nel modo illustrato nella tabella seguente.The regular expression that uses the | character, \bgr(a|e)y\b, is interpreted as shown in the following table.

ModelloPattern DescrizioneDescription
\b Inizia dal confine di una parola.Start at a word boundary.
gr Corrisponde ai caratteri "gr".Match the characters "gr".
(a|e) Corrisponde a una "a" o una "e".Match either an "a" or an "e".
y\b Corrisponde a una "y" in un confine di parola.Match a "y" on a word boundary.

Il carattere | può essere usato anche per trovare una corrispondenza di tipo either/or con più caratteri o sottoesspressioni, che possono includere qualsiasi combinazione di valori letterali carattere ed elementi del linguaggio di espressioni regolari.The | character can also be used to perform an either/or match with multiple characters or subexpressions, which can include any combination of character literals and regular expression language elements. La classe di caratteri non offre questa funzionalità. L'esempio seguente usa il carattere | per estrarre un numero di previdenza sociale (SSN, Social Security Number) degli Stati Uniti, che corrisponde a un numero a 9 cifre (d, digit) con il formato ddd-dd-dddd, oppure un identificativo del datore di lavoro (EIN, Employer Identification Number) degli Stati Uniti, che corrisponde a un numero a 9 cifre (d, digit) con il formato dd-ddddddd.(The character class does not provide this functionality.) The following example uses the | character to extract either a U.S. Social Security Number (SSN), which is a 9-digit number with the format ddd-dd-dddd, or a U.S. Employer Identification Number (EIN), which is a 9-digit number with the format dd-ddddddd.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b";
      string input = "01-9999999 020-333333 777-88-9999";
      Console.WriteLine("Matches for {0}:", pattern);
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index);
   }
}
// The example displays the following output:
//       Matches for \b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b:
//          01-9999999 at position 0
//          777-88-9999 at position 22
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b"
      Dim input As String = "01-9999999 020-333333 777-88-9999"
      Console.WriteLine("Matches for {0}:", pattern)
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index)
      Next   
   End Sub
End Module
' The example displays the following output:
'       Matches for \b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b:
'          01-9999999 at position 0
'          777-88-9999 at position 22

L'espressione regolare \b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b viene interpretata come illustrato nella tabella seguente.The regular expression \b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b is interpreted as shown in the following table.

ModelloPattern DescrizioneDescription
\b Inizia dal confine di una parola.Start at a word boundary.
(\d{2}-\d{7}|\d{3}-\d{2}-\d{4}) Corrisponde a una delle due opzioni seguenti: due cifre decimali seguite da un trattino seguito da sette cifre decimali oppure tre cifre decimali, un trattino, due cifre decimali, un altro trattino e quattro cifre decimali.Match either of the following: two decimal digits followed by a hyphen followed by seven decimal digits; or three decimal digits, a hyphen, two decimal digits, another hyphen, and four decimal digits.
\d Termina la corrispondenza sul confine di parola.End the match at a word boundary.

Torna all'inizioBack to top

Corrispondenza condizionale con un'espressioneConditional Matching with an Expression

Questo elemento del linguaggio tenta di trovare una corrispondenza con uno di due criteri, a seconda della possibilità di trovare una corrispondenza con un criterio iniziale.This language element attempts to match one of two patterns depending on whether it can match an initial pattern. La sintassi è la seguente:Its syntax is:

(?( espressione ) | no )(?( expression ) yes | no )

dove espressione è il criterio iniziale per la corrispondenza, è il criterio di corrispondenza se viene trovata una corrispondenza per espressione e no è il criterio facoltativo di corrispondenza se non viene trovata una corrispondenza per espressione .where expression is the initial pattern to match, yes is the pattern to match if expression is matched, and no is the optional pattern to match if expression is not matched. Il motore delle espressioni regolari considera espressione come un'asserzione di larghezza zero, ovvero questo motore non avanza nel flusso di input dopo aver valutato espressione.The regular expression engine treats expression as a zero-width assertion; that is, the regular expression engine does not advance in the input stream after it evaluates expression. Questo costrutto è pertanto equivalente a quanto segue:Therefore, this construct is equivalent to the following:

(?(?= espressione ) | no )(?(?= expression ) yes | no )

dove (?=espressione) è un costrutto di asserzione di larghezza zero.where (?=expression) is a zero-width assertion construct. Per altre informazioni, vedere Costrutti di raggruppamento. Poiché il motore delle espressioni regolari interpreta espressione come un ancoraggio (un'asserzione di larghezza zero), espressione deve essere un'asserzione di larghezza zero (per altre informazioni, vedere Ancoraggi in espressioni regolari) o una sottoespressione contenuta in yes.(For more information, see Grouping Constructs.) Because the regular expression engine interprets expression as an anchor (a zero-width assertion), expression must either be a zero-width assertion (for more information, see Anchors) or a subexpression that is also contained in yes. In caso contrario, non è possibile trovare una corrispondenza per il criterio yes.Otherwise, the yes pattern cannot be matched.

Nota

Se espressioneè un gruppo di acquisizione denominato o numerato, il costrutto di alternanza viene interpretato come un test di acquisizione. Per altre informazioni, vedere la sezione successiva, Corrispondenza condizionale in base a un gruppo Capture valido.If expressionis a named or numbered capturing group, the alternation construct is interpreted as a capture test; for more information, see the next section, Conditional Matching Based on a Valid Capture Group. In altre parole, il motore delle espressioni regolari non tenta di trovare la corrispondenza con la sottostringa acquisita, ma verifica invece la presenza o l'assenza del gruppo.In other words, the regular expression engine does not attempt to match the captured substring, but instead tests for the presence or absence of the group.

L'esempio seguente è una variante dell'esempio visualizzato nella sezione relativa ai criteri di ricerca either/or con |.The following example is a variation of the example that appears in the Either/Or Pattern Matching with | section. L'esempio usa la corrispondenza condizionale per determinare se i primi tre caratteri dopo un confine di parola sono due cifre seguite da un trattino.It uses conditional matching to determine whether the first three characters after a word boundary are two digits followed by a hyphen. In caso affermativo, viene effettuato un tentativo di trovare una corrispondenza con un identificativo del datore di lavoro (EIN) degli Stati Uniti.If they are, it attempts to match a U.S. Employer Identification Number (EIN). In caso contrario, viene effettuato un tentativo di trovare una corrispondenza con un numero di previdenza sociale (SSN) degli Stati Uniti.If not, it attempts to match a U.S. Social Security Number (SSN).

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(?(\d{2}-)\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b";
      string input = "01-9999999 020-333333 777-88-9999";
      Console.WriteLine("Matches for {0}:", pattern);
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index);
   }
}
// The example displays the following output:
//       Matches for \b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b:
//          01-9999999 at position 0
//          777-88-9999 at position 22
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(?(\d{2}-)\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b"
      Dim input As String = "01-9999999 020-333333 777-88-9999"
      Console.WriteLine("Matches for {0}:", pattern)
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index)
      Next   
   End Sub
End Module
' The example displays the following output:
'       Matches for \b(?(\d{2}-)\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b:
'          01-9999999 at position 0
'          777-88-9999 at position 22

Il criterio di ricerca di espressioni regolari \b(?(\d{2}-)\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b è interpretato nel modo illustrato nella tabella seguente.The regular expression pattern \b(?(\d{2}-)\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b is interpreted as shown in the following table.

ModelloPattern DescrizioneDescription
\b Inizia dal confine di una parola.Start at a word boundary.
(?(\d{2}-) Determina se i tre caratteri successivi sono costituiti da due cifre seguite da un trattino.Determine whether the next three characters consist of two digits followed by a hyphen.
\d{2}-\d{7} Se il criterio precedente viene soddisfatto, trova la corrispondenza con due cifre seguite da un trattino seguito da sette cifre.If the previous pattern matches, match two digits followed by a hyphen followed by seven digits.
\d{3}-\d{2}-\d{4} Se il criterio precedente non viene soddisfatto, trova la corrispondenza con tre cifre decimali, un trattino, due cifre decimali, un altro trattino e quattro cifre decimali.If the previous pattern does not match, match three decimal digits, a hyphen, two decimal digits, another hyphen, and four decimal digits.
\b Trova la corrispondenza di un confine di parola.Match a word boundary.

Torna all'inizioBack to top

Corrispondenza condizionale in base a un gruppo di acquisizione validoConditional Matching Based on a Valid Captured Group

Tramite questo elemento di linguaggio viene effettuato un tentativo di corrispondenza con uno dei due modelli, a seconda dell'effettiva corrispondenza con un gruppo di acquisizione specificato.This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. La sintassi è la seguente:Its syntax is:

(?( nome ) | no )(?( name ) yes | no )

oppureor

(?( numero ) | no )(?( number ) yes | no )

dove nome è il nome e numero è il numero di un gruppo di acquisizione, è l'espressione di cui trovare la corrispondenza se per nome o numero è disponibile una corrispondenza e no è l'espressione facoltativa di cui trovare la corrispondenza in caso contrario.where name is the name and number is the number of a capturing group, yes is the expression to match if name or number has a match, and no is the optional expression to match if it does not.

Se nome non corrisponde al nome di un gruppo di acquisizione usato nel criterio di espressione regolare, il costrutto di alternanza viene interpretato come un test di espressione, come illustrato nella sezione precedente.If name does not correspond to the name of a capturing group that is used in the regular expression pattern, the alternation construct is interpreted as an expression test, as explained in the previous section. In genere, ciò significa che espressione restituisce false.Typically, this means that expression evaluates to false. Se numero non corrisponde a un gruppo di acquisizione numerato usato nel criterio di espressione regolare, il motore delle espressioni regolari genera un'eccezione ArgumentException.If number does not correspond to a numbered capturing group that is used in the regular expression pattern, the regular expression engine throws an ArgumentException.

L'esempio seguente è una variante dell'esempio visualizzato nella sezione relativa ai criteri di ricerca either/or con |.The following example is a variation of the example that appears in the Either/Or Pattern Matching with | section. L'esempio usa un gruppo di acquisizione denominato n2 costituito da due cifre seguite da un trattino.It uses a capturing group named n2 that consists of two digits followed by a hyphen. Il costrutto di alternanza verifica se per questo gruppo di acquisizione è presente una corrispondenza nella stringa di input.The alternation construct tests whether this capturing group has been matched in the input string. In caso affermativo, il costrutto di alternanza tenta di trovare la corrispondenza con le ultime sette cifre delle nove cifre di un identificativo del datore di lavoro (EIN) degli Stati Uniti.If it has, the alternation construct attempts to match the last seven digits of a nine-digit U.S. Employer Identification Number (EIN). In caso contrario, tenta di trovare la corrispondenza con le nove cifre di un numero di previdenza sociale (SSN) degli Stati Uniti.If it has not, it attempts to match a nine-digit U.S. Social Security Number (SSN).

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(?<n2>\d{2}-)?(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b";
      string input = "01-9999999 020-333333 777-88-9999";
      Console.WriteLine("Matches for {0}:", pattern);
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index);
   }
}
// The example displays the following output:
//       Matches for \b(?<n2>\d{2}-)?(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b:
//          01-9999999 at position 0
//          777-88-9999 at position 22
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
        Dim pattern As String = "\b(?<n2>\d{2}-)?(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b"
        Dim input As String = "01-9999999 020-333333 777-88-9999"
      Console.WriteLine("Matches for {0}:", pattern)
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index)
      Next   
   End Sub
End Module

Il criterio di ricerca di espressioni regolari \b(?<n2>\d{2}-)?(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b è interpretato nel modo illustrato nella tabella seguente.The regular expression pattern \b(?<n2>\d{2}-)?(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b is interpreted as shown in the following table.

ModelloPattern DescrizioneDescription
\b Inizia dal confine di una parola.Start at a word boundary.
(?<n2>\d{2}-)? Corrisponde a zero o una occorrenza di due cifre seguite da un trattino.Match zero or one occurrence of two digits followed by a hyphen. Il nome di questo gruppo di acquisizione è n2.Name this capturing group n2.
(?(n2) Verificare se per n2 è stata individuata una corrispondenza nella stringa di input.Test whether n2 was matched in the input string.
)\d{7} Se per n2 è stata individuata una corrispondenza, far corrispondere sette cifre decimali.If n2 was matched, match seven decimal digits.
|\d{3}-\d{2}-\d{4} Se per n2 non è stata trovata alcuna corrispondenza, far corrispondere tre cifre decimali, un trattino, due cifre decimali, un altro trattino e quattro cifre decimali.If n2 was not matched, match three decimal digits, a hyphen, two decimal digits, another hyphen, and four decimal digits.
\b Trova la corrispondenza di un confine di parola.Match a word boundary.

Nell'esempio seguente è illustrata una variante di questo esempio che usa un gruppo numerato anziché un gruppo denominato.A variation of this example that uses a numbered group instead of a named group is shown in the following example. Il criterio di espressione regolare è \b(\d{2}-)?(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b.Its regular expression pattern is \b(\d{2}-)?(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\d{2}-)?(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b";
      string input = "01-9999999 020-333333 777-88-9999";
      Console.WriteLine("Matches for {0}:", pattern);
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index);
   }
}
// The example display the following output:
//       Matches for \b(\d{2}-)?(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b:
//          01-9999999 at position 0
//          777-88-9999 at position 22
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
        Dim pattern As String = "\b(\d{2}-)?(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b"
        Dim input As String = "01-9999999 020-333333 777-88-9999"
      Console.WriteLine("Matches for {0}:", pattern)
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index)
      Next   
   End Sub
End Module
' The example displays the following output:
'       Matches for \b(\d{2}-)?(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b:
'          01-9999999 at position 0
'          777-88-9999 at position 22

Vedere ancheSee Also

Linguaggio di espressioni regolari - Riferimento rapidoRegular Expression Language - Quick Reference