Alternierungskonstrukte

Alternierungskonstrukte ändern einen regulären Ausdruck, um Entweder/Oder-Vergleiche oder konditionelle Vergleiche zuzulassen. .NET Framework unterstützt drei Alternierungskonstrukte:

• Mustervergleich mit |

• Bedingter Vergleich mit (? (Ausdruck) ja|nein)

• Bedingter Vergleich auf Grundlage einer gültigen Erfassungsgruppe

Mustervergleich mit |

Sie können den senkrechten Strich verwenden (|) Zeichen, das eine Entsprechung für ein beliebiges von einer Reihe von Mustern ist, wo das | Das Zeichen trennt jedes Muster.

Wie die positive Zeichenklasse, die |Das Zeichen kann verwendet werden, um eine Entsprechung für eines von einer Reihe von einzelnen Zeichen zu finden. Im folgenden Beispiel wird sowohl eine positive Zeichenklasse als auch ein Entweder/oder-Mustervergleich verwendet mit |Das Zeichen, um Vorkommen der Wörter "gray" oder "grey" in einer Zeichenfolge zu suchen. In diesem Fall | Das Zeichen erzeugt einen regulären Ausdruck, der ausführlicher ist.

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           

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           

Verwendet wird vom regulären Ausdruck | Das Zeichen, \bgr(a|e)y\b, wird wie in der folgenden Tabelle angezeigt interpretiert.

Mithilfe des |Das Zeichen kann verwendet werden, um eine Entweder/Oder-Übereinstimmung mit mehreren Zeichen oder Teilausdrücken auszuführen, die eine beliebige Kombination von Zeichenliteralen und regulären Ausdruckssprachelementen einschließen können. (Die Zeichenklasse stellt diese Funktionalität nicht bereit.) Das folgende Beispiel verwendet |Das Zeichen, das entweder ein U.S. extrahiert hat Die Sozialversicherungsnummer (SSN), die eine neunstellige Zahl mit dem Format ddd ist, -dd-dddd oder US- Arbeitgeber-ID (EIN), die eine neunstellige Zahl mit dem Format tt-ttttttt ist.

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

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

Der reguläre Ausdruck \b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b wird entsprechend der Darstellung in der folgenden Tabelle interpretiert.

Zurück nach oben

Bedingter Vergleich mit einem Ausdruck

Dieses Sprachelement versucht, eine Entsprechung für ein von zwei Mustern abhängig davon zu finden, ob es eine Entsprechung für ein ursprüngliches Muster finden kann. Die Syntax lautet:

(?(expression)yes|nein)

wobei Ausdruck das ursprüngliche Muster ist, mit dem eine Übereinstimmung erzielt werden muss, ja das Muster ist, mit dem eine Übereinstimmung erzielt werden muss, wenn eine Übereinstimmung mit Ausdruck vorliegt, und nein das optionale Muster ist, mit dem eine Übereinstimmung erzielt werden muss, wenn keine Übereinstimmung mit Ausdruck vorliegt. Das Modul für reguläre Ausdrücke behandelt Ausdruck als Assertion mit der Breite null; das heißt, das Modul für reguläre Ausdrücke wechselt nicht in den Eingabestream, nachdem Ausdruck ausgewertet wurde. Daher entspricht dieses Konstrukt dem folgenden Objekt:

(?(?=expression)yes|nein)

wobei (?=Ausdruck) ein Assertionskonstrukt mit einer Breite gleich null ist. (Weitere Informationen finden Sie unter Gruppierungskonstrukte.) Da das Modul für reguläre Ausdrücke Ausdruck als Anker (eine Assertion mit der Breite null) interpretiert, muss Ausdruck entweder eine Assertion mit der Breite null (weitere Informationen erhalten Sie unter Anker in regulären Ausdrücken) oder ein Teilausdruck sein, der auch in ja enthalten ist. Andernfalls kann das ja-Muster kann nicht zugeordnet werden.

Hinweis

Wenn Ausdruck eine benannte oder nummerierte Erfassungsgruppe ist, wird das Alternierungskonstrukt als Erfassungstest interpretiert. Weitere Informationen finden Sie im nächsten Abschnitt, Bedingter Vergleich auf Grundlage einer gültigen Erfassungsgruppe.Anders ausgedrückt versucht das Modul für reguläre Ausdrücke nicht, eine Entsprechung für die erfasste Teilzeichenfolge zu finden, sondern es wird getestet, ob die Gruppe vorhanden bzw. nicht vorhanden ist.

Das folgende Beispiel ist eine Abwandlung des Beispiels, das im Abschnitt Entweder/Oder-Mustervergleiche mit | angezeigt wird. Mit einem bedingten Vergleich wird bestimmt, ob die ersten drei Zeichen nach einer Wortgrenze zwei Ziffern sind, auf die ein Bindestrich folgt. Wenn dies der Fall ist, wird versucht eine Entsprechung für eine US-Einheit zu finden. Arbeitgeber-ID (EIN). Wenn dies nicht der Fall ist, wird versucht eine Entsprechung für eine US-Einheit zu finden. Sozialversicherungsnummer (SVN).

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

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

Das Muster für reguläre Ausdrücke \b(?(\d{2}-)\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b wird entsprechend der folgenden Tabelle interpretiert:

Zurück nach oben

Bedingter Vergleich auf Grundlage einer gültigen Erfassungsgruppe

Dieses Sprachelement versucht, eine Entsprechung für ein von zwei Mustern abhängig davon zu finden, ob es eine Entsprechung für eine angegebene erfasste Gruppe finden kann. Die Syntax lautet:

(?(name)yes|nein)

oder

(?(number)yes|nein)

wobei Name der Name ist, Nummer die Nummer einer Erfassungsgruppe ist, ja der Ausdruck ist, mit dem eine Übereinstimmung erzielt werden muss, wenn für Name oder Nummer Übereinstimmungen vorliegen, und nein der optionale Ausdruck ist, mit dem eine Übereinstimmung erzielt werden muss, wenn dies nicht der Fall ist.

Wenn Name nicht dem Namen einer Erfassungsgruppe entspricht, der im Muster eines regulären Ausdrucks verwendet wird, wird das Alternierungskonstrukt als Ausdruckstest interpretiert (siehe Erläuterung im vorherigen Abschnitt). In der Regel bedeutet dies, dass Ausdruck false ergibt. Wenn Zahl nicht einer nummerierten Erfassungsgruppe entspricht, die im Muster eines regulären Ausdrucks verwendet wird, löst das Modul für reguläre Ausdrücke eine ArgumentException aus.

Das folgende Beispiel ist eine Abwandlung des Beispiels, das im Abschnitt Entweder/Oder-Mustervergleiche mit | angezeigt wird. Eine Erfassungsgruppe mit dem Namen n2 wird verwendet, die aus zwei Ziffern gefolgt von einem Bindestrich besteht. Das Alternierungskonstrukt testet, ob für diese Erfassungsgruppe in der Eingabezeichenfolge eine Übereinstimmung gefunden wurde. Wenn dies der Fall ist, wird versucht, eine Übereinstimmung mit den letzten sieben Ziffern einer US-Einheit zu finden. Arbeitgeber-ID (EIN). Wenn dies nicht der Fall ist, wird versucht eine Entsprechung für eine US-Einheit zu finden. Sozialversicherungsnummer (SVN).

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

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

Das Muster für reguläre Ausdrücke \b(?<n2>\d{2}-)*(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b wird entsprechend der folgenden Tabelle interpretiert:

Eine Variation dieses Beispiels, in dem eine nummerierte Gruppe statt einer benannten Gruppe verwendet wird, wird im folgenden Beispiel gezeigt. Das Muster eines regulären Ausdrucks ist \b(\d{2}-)*(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b

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

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

Zurück nach oben

Siehe auch

Konzepte

Sprachelemente für reguläre Ausdrücke