Anker in regulären Ausdrücken

Anker oder unteilbare Nullbreitenassertions geben eine Position in der Zeichenfolge an, an der eine Übereinstimmung auftreten muss. Wenn Sie im Suchausdruck einen Anker verwenden, durchsucht das Modul für reguläre Ausdrücke nicht die Zeichenfolge oder durchläuft Zeichen; es sucht nur an der angegebenen Position nach einer Übereinstimmung. Beispielsweise gibt ^ an, dass der Abgleich am Anfang einer Zeile oder Zeichenfolge beginnen muss. Daher findet der reguläre Ausdruck ^http: die Übereinstimmung mit "http:" nur dann, wenn es am Anfang einer Zeile steht. In der folgenden Tabelle sind die Anker aufgeführt, die von den regulären .NET Framework-Ausdrücken unterstützt werden.

Anker	Beschreibungen
^	Die Übereinstimmung muss am Anfang der Zeichenfolge oder Zeile auftreten. Weitere Informationen finden Sie unter Anfang der Zeichenfolge oder Zeile.
$	Die Übereinstimmung muss am Ende der Zeichenfolge oder Zeile oder vor \n am Ende der Zeile oder Zeichenfolge auftreten. Weitere Informationen finden Sie unter End of String or Line.
\A	Die Übereinstimmung darf nur am Anfang der Zeichenfolge auftreten (mehrere Zeilen werden nicht unterstützt). Weitere Informationen finden Sie unter Start of String Only.
\Z	Die Übereinstimmung muss am Ende der Zeichenfolge oder vor \n am Ende der Zeichenfolge auftreten. Weitere Informationen finden Sie unter End of String or Before Ending Newline.
\z	Die Übereinstimmung darf nur am Ende der Zeichenfolge auftreten. Weitere Informationen finden Sie unter End of String Only.
\G	Die Übereinstimmung muss an dem Punkt beginnen, an dem die vorherige Übereinstimmung endete. Weitere Informationen finden Sie unter Contiguous Matches.
\b	Die Übereinstimmung muss an einer Wortgrenze auftreten. Weitere Informationen finden Sie unter Word Boundary.
\B	Die Übereinstimmung darf nicht an einer Wortgrenze erfolgen. Weitere Informationen finden Sie unter Non-Word Boundary.

Beginn der Zeichenfolge oder Zeile: ^

Der ^-Anker gibt an, dass das folgende Muster an der ersten Zeichenposition der Zeichenfolge beginnen muss. Wenn Sie ^ mit der RegexOptions.Multiline-Option (siehe Regular Expression Options) verwenden, muss die Übereinstimmung am Anfang jeder Zeile auftreten.

Im folgenden Beispiel wird der ^-Anker in einem regulären Ausdruck verwendet, der Informationen zu den Jahren extrahiert, in denen bestimmte professionelle Baseballteams vorhanden waren. Im Beispiel werden zwei Überladungen der Regex.Matches()-Methode aufgerufen:

• Der Aufruf der Matches(String, String)-Überladung sucht nur die erste Teilzeichenfolge in der Eingabezeichenfolge, die mit dem Muster eines regulären Ausdrucks übereinstimmt.

• Der Aufruf der Matches(String, String, RegexOptions)-Überladung bei Festlegung des options-Parameters auf RegexOptions.Multiline sucht alle fünf Teilzeichenfolgen.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim startPos As Integer = 0
      Dim endPos As Integer = 70
      Dim input As String = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + vbCrLf + _
                            "Chicago Cubs, National League, 1903-present" + vbCrLf + _
                            "Detroit Tigers, American League, 1901-present" + vbCrLf + _
                            "New York Giants, National League, 1885-1957" + vbCrLf + _
                            "Washington Senators, American League, 1901-1960" + vbCrLf  

      Dim pattern As String = "^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+"
      Dim match As Match

      ' Provide minimal validation in the event the input is invalid.
      If input.Substring(startPos, endPos).Contains(",") Then
         match = Regex.Match(input, pattern)
         Do While match.Success
            Console.Write("The {0} played in the {1} in", _
                              match.Groups(1).Value, match.Groups(4).Value)
            For Each capture As Capture In match.Groups(5).Captures
               Console.Write(capture.Value)
            Next
            Console.WriteLine(".")
            startPos = match.Index + match.Length 
            endPos = CInt(IIf(startPos + 70 <= input.Length, 70, input.Length - startPos))
            If Not input.Substring(startPos, endPos).Contains(",") Then Exit Do
            match = match.NextMatch()            
         Loop
         Console.WriteLine()                               
      End If      

      startPos = 0
      endPos = 70
      If input.Substring(startPos, endPos).Contains(",") Then
         match = Regex.Match(input, pattern, RegexOptions.Multiline)
         Do While match.Success
            Console.Write("The {0} played in the {1} in", _
                              match.Groups(1).Value, match.Groups(4).Value)
            For Each capture As Capture In match.Groups(5).Captures
               Console.Write(capture.Value)
            Next
            Console.WriteLine(".")
            startPos = match.Index + match.Length 
            endPos = CInt(IIf(startPos + 70 <= input.Length, 70, input.Length - startPos))
            If Not input.Substring(startPos, endPos).Contains(",") Then Exit Do
            match = match.NextMatch()            
         Loop
         Console.WriteLine()                               
      End If      


'       For Each match As Match in Regex.Matches(input, pattern, RegexOptions.Multiline)
'          Console.Write("The {0} played in the {1} in", _
'                            match.Groups(1).Value, match.Groups(4).Value)
'          For Each capture As Capture In match.Groups(5).Captures
'             Console.Write(capture.Value)
'          Next
'          Console.WriteLine(".")
'       Next
   End Sub
End Module
' The example displays the following output:
'    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
'    
'    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
'    The Chicago Cubs played in the National League in 1903-present.
'    The Detroit Tigers played in the American League in 1901-present.
'    The New York Giants played in the National League in 1885-1957.
'    The Washington Senators played in the American League in 1901-1960.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      int startPos = 0, endPos = 70;
      string input = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957\n" +
                     "Chicago Cubs, National League, 1903-present\n" + 
                     "Detroit Tigers, American League, 1901-present\n" + 
                     "New York Giants, National League, 1885-1957\n" +  
                     "Washington Senators, American League, 1901-1960\n";   
      string pattern = @"^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+";
      Match match;

      if (input.Substring(startPos, endPos).Contains(",")) {
         match = Regex.Match(input, pattern);
         while (match.Success) {
            Console.Write("The {0} played in the {1} in", 
                              match.Groups[1].Value, match.Groups[4].Value);
            foreach (Capture capture in match.Groups[5].Captures)
               Console.Write(capture.Value);

            Console.WriteLine(".");
            startPos = match.Index + match.Length;
            endPos = startPos + 70 <= input.Length ? 70 : input.Length - startPos;
            if (! input.Substring(startPos, endPos).Contains(",")) break;
            match = match.NextMatch();
         }
         Console.WriteLine();
      }

      if (input.Substring(startPos, endPos).Contains(",")) {
         match = Regex.Match(input, pattern, RegexOptions.Multiline);
         while (match.Success) {
            Console.Write("The {0} played in the {1} in", 
                              match.Groups[1].Value, match.Groups[4].Value);
            foreach (Capture capture in match.Groups[5].Captures)
               Console.Write(capture.Value);

            Console.WriteLine(".");
            startPos = match.Index + match.Length;
            endPos = startPos + 70 <= input.Length ? 70 : input.Length - startPos;
            if (! input.Substring(startPos, endPos).Contains(",")) break;
            match = match.NextMatch();
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
//    
//    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
//    The Chicago Cubs played in the National League in 1903-present.
//    The Detroit Tigers played in the American League in 1901-present.
//    The New York Giants played in the National League in 1885-1957.
//    The Washington Senators played in the American League in 1901-1960.

Das Muster für reguläre Ausdrücke ^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+ wird entsprechend der folgenden Tabelle definiert:

Muster	Beschreibungen
^	Starten Sie den Abgleich am Anfang der Eingabezeichenfolge (oder am Anfang der Zeile, wenn die Methode mit der RegexOptions.Multiline-Option aufgerufen wird).
((\w+(\s*)){2,}	Suchen Sie nach einer Übereinstimmung mit einem oder mehreren Wortzeichen gefolgt entweder von 0 (null) oder von einem Leerzeichen (genau zwei Mal). Dies ist die erste Erfassungsgruppe. Dieser Ausdruck definiert auch eine zweite und dritte Erfassungsgruppe: Die zweite besteht aus dem erfassten Wort, und die dritte besteht aus den erfassten Leerzeichen.
,\s	Suchen Sie nach einer Übereinstimmung mit einem Komma gefolgt von einem Leerzeichen.
(\w+\s\w+)	Suchen Sie nach einer Übereinstimmung mit einem oder mehreren Wortzeichen gefolgt von mindestens einem Wortzeichen. Dies ist die vierte Erfassungsgruppe.
,	Entsprechung für ein Komma finden.
\s\d{4}	Suchen Sie nach einer Übereinstimmung mit einem von vier Dezimalstellen gefolgten Leerzeichen.
(-(\d{4}|present))*	Suchen Sie nach einer Übereinstimmung mit 0 (null) oder einem Vorkommen eines Bindestrichs gefolgt von vier Dezimalstellen oder der Zeichenfolge "present". Dies ist die sechste Erfassungsgruppe. Schließt auch eine siebte Erfassungsgruppe ein.
,*	Suchen Sie nach einer Übereinstimmung mit 0 (null) oder einem Vorkommen eines Kommas.
(\s\d{4}(-(\d{4}|present))*,*)+	Suchen Sie nach einer Übereinstimmung mit einem oder mehreren Vorkommen von Folgendem: ein Leerzeichen, vier Dezimalstellen, 0 (null) oder ein Vorkommen eines Bindestrichs gefolgt von vier Dezimalstellen oder der Zeichenfolge "present" und 0 (null) oder ein Komma. Dies ist die fünfte Erfassungsgruppe.

Zurück nach oben

Ende der Zeichenfolge oder Zeile: $

Der $-Anker gibt an, dass das vorangehende Muster am Ende der Eingabezeichenfolge oder vor \n am Ende der Eingabezeichenfolge auftreten muss.

Wenn Sie $ mit der RegexOptions.Multiline-Option verwenden, kann die Übereinstimmung auch am Ende einer Zeile auftreten. Beachten Sie, dass $ mit \n übereinstimmt, aber nicht mit \r\n (die Kombination von Wagenrücklauf und Zeilenumbruchzeichen oder CR/LF). Um eine Entsprechung für die CR/LF-Zeichenkombination zu finden, schließen \r?$ in das Muster des regulären Ausdrucks ein.

Im folgenden Beispiel wird der $-Anker zum Muster des regulären Ausdrucks hinzugefügt, der im Beispiel im Abschnitt Anfang der Zeichenfolge oder Zeile verwendet wurde. Bei Verwendung mit der ursprünglichen Eingabezeichenfolge, die fünf Textzeilen umfasst, kann mit der Regex.Matches(String, String)-Methode keine Übereinstimmung gefunden werden, da das Ende der ersten Zeile nicht mit dem $-Muster übereinstimmt. Wenn die ursprüngliche Eingabezeichenfolge in ein Zeichenfolgenarray geteilt wird, kann mit der Regex.Matches(String, String)-Methode eine Entsprechung für jede der fünf Zeilen gefunden werden. Wenn die Regex.Matches(String, String, RegexOptions)-Methode mit dem auf RegexOptions.Multiline festgelegten options-Parameter aufgerufen wird, werden keine Übereinstimmungen gefunden, da das Muster eines regulären Ausdrucks nicht maßgeblich für das Wagenrücklaufelement (\u+000D) ist. Jedoch wenn das Muster eines regulären Ausdrucks geändert wird, indem $ durch \r?$ ersetzt wird, ergibt der Aufruf der Regex.Matches(String, String, RegexOptions)-Methode, sofern der options-Parameter auf RegexOptions.Multiline festgelegt ist, wieder fünf Übereinstimmungen.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim startPos As Integer = 0
      Dim endPos As Integer = 70
      Dim input As String = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + vbCrLf + _
                            "Chicago Cubs, National League, 1903-present" + vbCrLf + _
                            "Detroit Tigers, American League, 1901-present" + vbCrLf + _
                            "New York Giants, National League, 1885-1957" + vbCrLf + _
                            "Washington Senators, American League, 1901-1960" + vbCrLf  

      Dim basePattern As String = "^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+"
      Dim match As Match

      Dim pattern As String = basePattern + "$"
      Console.WriteLine("Attempting to match the entire input string:")
      ' Provide minimal validation in the event the input is invalid.
      If input.Substring(startPos, endPos).Contains(",") Then
         match = Regex.Match(input, pattern)
         Do While match.Success
            Console.Write("The {0} played in the {1} in", _
                              match.Groups(1).Value, match.Groups(4).Value)
            For Each capture As Capture In match.Groups(5).Captures
               Console.Write(capture.Value)
            Next
            Console.WriteLine(".")
            startPos = match.Index + match.Length 
            endPos = CInt(IIf(startPos + 70 <= input.Length, 70, input.Length - startPos))
            If Not input.Substring(startPos, endPos).Contains(",") Then Exit Do
            match = match.NextMatch()            
         Loop
         Console.WriteLine()                               
      End If      

      Dim teams() As String = input.Split(New String() { vbCrLf }, StringSplitOptions.RemoveEmptyEntries)
      Console.WriteLine("Attempting to match each element in a string array:")
      For Each team As String In teams
         If team.Length > 70 Then Continue For
         match = Regex.Match(team, pattern)
         If match.Success Then
            Console.Write("The {0} played in the {1} in", _
                           match.Groups(1).Value, match.Groups(4).Value)
            For Each capture As Capture In match.Groups(5).Captures
               Console.Write(capture.Value)
            Next
            Console.WriteLine(".")
         End If
      Next
      Console.WriteLine()

      startPos = 0
      endPos = 70
      Console.WriteLine("Attempting to match each line of an input string with '$':")
      ' Provide minimal validation in the event the input is invalid.
      If input.Substring(startPos, endPos).Contains(",") Then
         match = Regex.Match(input, pattern, RegexOptions.Multiline)
         Do While match.Success
            Console.Write("The {0} played in the {1} in", _
                              match.Groups(1).Value, match.Groups(4).Value)
            For Each capture As Capture In match.Groups(5).Captures
               Console.Write(capture.Value)
            Next
            Console.WriteLine(".")
            startPos = match.Index + match.Length 
            endPos = CInt(IIf(startPos + 70 <= input.Length, 70, input.Length - startPos))
            If Not input.Substring(startPos, endPos).Contains(",") Then Exit Do
            match = match.NextMatch()            
         Loop
         Console.WriteLine()                               
      End If      


      startPos = 0
      endPos = 70
      pattern = basePattern + "\r?$" 
      Console.WriteLine("Attempting to match each line of an input string with '\r?$':")
      ' Provide minimal validation in the event the input is invalid.
      If input.Substring(startPos, endPos).Contains(",") Then
         match = Regex.Match(input, pattern, RegexOptions.Multiline)
         Do While match.Success
            Console.Write("The {0} played in the {1} in", _
                              match.Groups(1).Value, match.Groups(4).Value)
            For Each capture As Capture In match.Groups(5).Captures
               Console.Write(capture.Value)
            Next
            Console.WriteLine(".")
            startPos = match.Index + match.Length 
            endPos = CInt(IIf(startPos + 70 <= input.Length, 70, input.Length - startPos))
            If Not input.Substring(startPos, endPos).Contains(",") Then Exit Do
            match = match.NextMatch()            
         Loop
         Console.WriteLine()                               
      End If      
   End Sub
End Module
' The example displays the following output:
'    Attempting to match the entire input string:
'    
'    Attempting to match each element in a string array:
'    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
'    The Chicago Cubs played in the National League in 1903-present.
'    The Detroit Tigers played in the American League in 1901-present.
'    The New York Giants played in the National League in 1885-1957.
'    The Washington Senators played in the American League in 1901-1960.
'    
'    Attempting to match each line of an input string with '$':
'    
'    Attempting to match each line of an input string with '\r+$':
'    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
'    The Chicago Cubs played in the National League in 1903-present.
'    The Detroit Tigers played in the American League in 1901-present.
'    The New York Giants played in the National League in 1885-1957.
'    The Washington Senators played in the American League in 1901-1960.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      int startPos = 0, endPos = 70;
      string cr = Environment.NewLine;
      string input = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + cr +
                     "Chicago Cubs, National League, 1903-present" + cr + 
                     "Detroit Tigers, American League, 1901-present" + cr + 
                     "New York Giants, National League, 1885-1957" + cr +  
                     "Washington Senators, American League, 1901-1960" + cr;   
      Match match;

      string basePattern = @"^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+";
      string pattern = basePattern + "$";
      Console.WriteLine("Attempting to match the entire input string:");
      if (input.Substring(startPos, endPos).Contains(",")) {
         match = Regex.Match(input, pattern);
         while (match.Success) {
            Console.Write("The {0} played in the {1} in", 
                              match.Groups[1].Value, match.Groups[4].Value);
            foreach (Capture capture in match.Groups[5].Captures)
               Console.Write(capture.Value);

            Console.WriteLine(".");
            startPos = match.Index + match.Length;
            endPos = startPos + 70 <= input.Length ? 70 : input.Length - startPos;
            if (! input.Substring(startPos, endPos).Contains(",")) break;
            match = match.NextMatch();
         }
         Console.WriteLine();
      }

      string[] teams = input.Split(new String[] { cr }, StringSplitOptions.RemoveEmptyEntries);
      Console.WriteLine("Attempting to match each element in a string array:");
      foreach (string team in teams)
      {
         if (team.Length > 70) continue;

         match = Regex.Match(team, pattern);
         if (match.Success)
         {
            Console.Write("The {0} played in the {1} in", 
                          match.Groups[1].Value, match.Groups[4].Value);
            foreach (Capture capture in match.Groups[5].Captures)
               Console.Write(capture.Value);
            Console.WriteLine(".");
         }
      }
      Console.WriteLine();

      startPos = 0;
      endPos = 70;
      Console.WriteLine("Attempting to match each line of an input string with '$':");
      if (input.Substring(startPos, endPos).Contains(",")) {
         match = Regex.Match(input, pattern, RegexOptions.Multiline);
         while (match.Success) {
            Console.Write("The {0} played in the {1} in", 
                              match.Groups[1].Value, match.Groups[4].Value);
            foreach (Capture capture in match.Groups[5].Captures)
               Console.Write(capture.Value);

            Console.WriteLine(".");
            startPos = match.Index + match.Length;
            endPos = startPos + 70 <= input.Length ? 70 : input.Length - startPos;
            if (! input.Substring(startPos, endPos).Contains(",")) break;
            match = match.NextMatch();
         }
         Console.WriteLine();
      }

      startPos = 0;
      endPos = 70;
      pattern = basePattern + "\r?$"; 
      Console.WriteLine(@"Attempting to match each line of an input string with '\r?$':");
      if (input.Substring(startPos, endPos).Contains(",")) {
         match = Regex.Match(input, pattern, RegexOptions.Multiline);
         while (match.Success) {
            Console.Write("The {0} played in the {1} in", 
                              match.Groups[1].Value, match.Groups[4].Value);
            foreach (Capture capture in match.Groups[5].Captures)
               Console.Write(capture.Value);

            Console.WriteLine(".");
            startPos = match.Index + match.Length;
            endPos = startPos + 70 <= input.Length ? 70 : input.Length - startPos;
            if (! input.Substring(startPos, endPos).Contains(",")) break;
            match = match.NextMatch();
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//    Attempting to match the entire input string:
//    
//    Attempting to match each element in a string array:
//    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
//    The Chicago Cubs played in the National League in 1903-present.
//    The Detroit Tigers played in the American League in 1901-present.
//    The New York Giants played in the National League in 1885-1957.
//    The Washington Senators played in the American League in 1901-1960.
//    
//    Attempting to match each line of an input string with '$':
//    
//    Attempting to match each line of an input string with '\r+$':
//    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
//    The Chicago Cubs played in the National League in 1903-present.
//    The Detroit Tigers played in the American League in 1901-present.
//    The New York Giants played in the National League in 1885-1957.
//    The Washington Senators played in the American League in 1901-1960.

Zurück nach oben

Nur Beginn der Zeichenfolge: \A

Der \A-Anker gibt an, dass am Beginn der Eingabezeichenfolge eine Übereinstimmung auftreten muss. Mit dem ^-Anker identisch, außer dass \A die RegexOptions.Multiline-Option ignoriert. Daher kann es eine Übereinstimmung nur mit dem Beginn der ersten Zeile in einer mehrzeiligen Eingabezeichenfolge geben.

Das folgende Beispiel ähnelt den Beispielen für den ^-Anker und den $-Anker. Verwendet den \A-Anker in einem regulären Ausdruck, der Informationen zu den Jahren extrahiert, in denen bestimmte professionelle Baseballteams vorhanden waren. Die Eingabezeichenfolge umfasst fünf Zeilen. Der Aufruf der Regex.Matches(String, String, RegexOptions)-Methode sucht nur die erste Teilzeichenfolge in der Eingabezeichenfolge, die mit dem Muster eines regulären Ausdrucks übereinstimmt. Wie das Beispiel zeigt, hat die Multiline-Option keine Auswirkungen.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim startPos As Integer = 0
      Dim endPos As Integer = 70
      Dim input As String = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + vbCrLf + _
                            "Chicago Cubs, National League, 1903-present" + vbCrLf + _
                            "Detroit Tigers, American League, 1901-present" + vbCrLf + _
                            "New York Giants, National League, 1885-1957" + vbCrLf + _
                            "Washington Senators, American League, 1901-1960" + vbCrLf  

      Dim pattern As String = "\A((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+"
      Dim match As Match

      ' Provide minimal validation in the event the input is invalid.
      If input.Substring(startPos, endPos).Contains(",") Then
         match = Regex.Match(input, pattern, RegexOptions.Multiline)
         Do While match.Success
            Console.Write("The {0} played in the {1} in", _
                              match.Groups(1).Value, match.Groups(4).Value)
            For Each capture As Capture In match.Groups(5).Captures
               Console.Write(capture.Value)
            Next
            Console.WriteLine(".")
            startPos = match.Index + match.Length 
            endPos = CInt(IIf(startPos + 70 <= input.Length, 70, input.Length - startPos))
            If Not input.Substring(startPos, endPos).Contains(",") Then Exit Do
            match = match.NextMatch()            
         Loop
         Console.WriteLine()                               
      End If      
   End Sub   
End Module
' The example displays the following output:
'    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      int startPos = 0, endPos = 70;
      string input = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957\n" +
                     "Chicago Cubs, National League, 1903-present\n" + 
                     "Detroit Tigers, American League, 1901-present\n" + 
                     "New York Giants, National League, 1885-1957\n" +  
                     "Washington Senators, American League, 1901-1960\n";   

      string pattern = @"\A((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+";
      Match match;

      if (input.Substring(startPos, endPos).Contains(",")) {
         match = Regex.Match(input, pattern, RegexOptions.Multiline);
         while (match.Success) {
            Console.Write("The {0} played in the {1} in", 
                              match.Groups[1].Value, match.Groups[4].Value);
            foreach (Capture capture in match.Groups[5].Captures)
               Console.Write(capture.Value);

            Console.WriteLine(".");
            startPos = match.Index + match.Length;
            endPos = startPos + 70 <= input.Length ? 70 : input.Length - startPos;
            if (! input.Substring(startPos, endPos).Contains(",")) break;
            match = match.NextMatch();
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.

Zurück nach oben

Ende der Zeichenfolge oder vor dem Beenden von Zeilenumbruch: \Z

Der \Z-Anker gibt an, dass eine Übereinstimmung am Ende der Eingabezeichenfolge oder vor \n am Ende der Eingabezeichenfolge auftreten muss. Mit dem $-Anker identisch, außer dass \Z die RegexOptions.Multiline-Option ignoriert. Daher kann die Übereinstimmung in einer mehrzeiligen Zeichenfolge nur mit dem Ende der letzten Zeile oder der letzten Zeile vor \n auftreten.

Beachten Sie, dass \Z mit \n, aber nicht mit \r\n übereinstimmt (der CR/LF-Zeichenkombination). Schließen Sie zum Anpassen von CR/LF \r?\Z ins Muster des regulären Ausdrucks ein.

Im folgenden Beispiel wird der \Z-Anker in einem regulären Ausdruck verwendet, der dem Beispiel aus dem Abschnitt Anfang der Zeichenfolge oder Zeile ähnelt, bei dem Informationen zu den Jahren extrahiert werden, in denen bestimmte professionelle Baseballteams vorhanden waren. Der Teilausdruck \r?\Z im regulären Ausdruck ^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+\r?\Z entspricht dem Ende einer Zeichenfolge sowie einer Zeichenfolge, die mit \n oder \r\n endet. Folglich stimmt jedes Element im Array mit dem Muster des regulären Ausdrucks überein.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957",  _
                            "Chicago Cubs, National League, 1903-present" + vbCrLf, _
                            "Detroit Tigers, American League, 1901-present" + vbLf, _
                            "New York Giants, National League, 1885-1957", _
                            "Washington Senators, American League, 1901-1960" + vbCrLf }  
      Dim pattern As String = "^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+\r?\Z"

      For Each input As String In inputs
         If input.Length > 70 Or Not input.Contains(",") Then Continue For

         Console.WriteLine(Regex.Escape(input))
         Dim match As Match = Regex.Match(input, pattern)
         If match.Success Then
            Console.WriteLine("   Match succeeded.")
         Else
            Console.WriteLine("   Match failed.")
         End If
      Next   
   End Sub
End Module
' The example displays the following output:
'    Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
'       Match succeeded.
'    Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
'       Match succeeded.
'    Detroit\ Tigers,\ American\ League,\ 1901-present\n
'       Match succeeded.
'    New\ York\ Giants,\ National\ League,\ 1885-1957
'       Match succeeded.
'    Washington\ Senators,\ American\ League,\ 1901-1960\r\n
'       Match succeeded.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957",  
                          "Chicago Cubs, National League, 1903-present" + Environment.NewLine, 
                          "Detroit Tigers, American League, 1901-present" + Regex.Unescape(@"\n"), 
                          "New York Giants, National League, 1885-1957", 
                          "Washington Senators, American League, 1901-1960" + Environment.NewLine}; 
      string pattern = @"^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+\r?\Z";

      foreach (string input in inputs)
      {
         if (input.Length > 70 || ! input.Contains(",")) continue;

         Console.WriteLine(Regex.Escape(input));
         Match match = Regex.Match(input, pattern);
         if (match.Success)
            Console.WriteLine("   Match succeeded.");
         else
            Console.WriteLine("   Match failed.");
      }   
   }
}
// The example displays the following output:
//    Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
//       Match succeeded.
//    Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
//       Match succeeded.
//    Detroit\ Tigers,\ American\ League,\ 1901-present\n
//       Match succeeded.
//    New\ York\ Giants,\ National\ League,\ 1885-1957
//       Match succeeded.
//    Washington\ Senators,\ American\ League,\ 1901-1960\r\n
//       Match succeeded.

Zurück nach oben

Nur Ende der Zeichenfolge: \z

Der \z-Anker gibt an, dass am Ende der Eingabezeichenfolge eine Übereinstimmung auftreten muss. Wie das $-Sprachelement ignoriert \z die RegexOptions.Multiline-Option. Im Gegensatz zum \Z-Sprachelement stimmt \z nicht mit einem \n-Zeichen am Ende einer Zeichenfolge überein. Daher kann es eine Übereinstimmung nur mit der letzten Zeile der Eingabezeichenfolge geben.

Im folgenden Beispiel wird der \z-Anker in einem regulären Ausdruck verwendet, der ansonsten mit dem Beispiel aus dem vorherigen Abschnitt übereinstimmt, bei dem Informationen zu den Jahren extrahiert werden, in denen bestimmte professionelle Baseballteams vorhanden waren. Im Beispiel wird versucht, jedes von fünf Elementen in einem Zeichenfolgenarray mit dem Muster eines regulären Ausdrucks ^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+\r?\z abzugleichen. Zwei der Zeichenfolgen enden mit Wagenrücklauf- und Zeilenvorschubzeichen, einer endet mit einem Zeilenvorschubzeichen, und zwei enden weder mit einem Wagenrücklauf- noch mit einem Zeilenvorschubzeichen. Wie die Ausgabe zeigt, stimmen nur die Zeichenfolgen ohne einen Wagenrücklauf oder einen Zeilenvorschub mit dem Muster überein.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957",  _
                            "Chicago Cubs, National League, 1903-present" + vbCrLf, _
                            "Detroit Tigers, American League, 1901-present" + vbLf, _
                            "New York Giants, National League, 1885-1957", _
                            "Washington Senators, American League, 1901-1960" + vbCrLf }  
      Dim pattern As String = "^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+\r?\z"

      For Each input As String In inputs
         If input.Length > 70 Or Not input.Contains(",") Then Continue For

         Console.WriteLine(Regex.Escape(input))
         Dim match As Match = Regex.Match(input, pattern)
         If match.Success Then
            Console.WriteLine("   Match succeeded.")
         Else
            Console.WriteLine("   Match failed.")
         End If
      Next   
   End Sub
End Module
' The example displays the following output:
'    Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
'       Match succeeded.
'    Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
'       Match failed.
'    Detroit\ Tigers,\ American\ League,\ 1901-present\n
'       Match failed.
'    New\ York\ Giants,\ National\ League,\ 1885-1957
'       Match succeeded.
'    Washington\ Senators,\ American\ League,\ 1901-1960\r\n
'       Match failed.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957", 
                          "Chicago Cubs, National League, 1903-present" + Environment.NewLine,
                          "Detroit Tigers, American League, 1901-present\\r",
                          "New York Giants, National League, 1885-1957",
                          "Washington Senators, American League, 1901-1960" + Environment.NewLine };  
      string pattern = @"^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+\r?\z";

      foreach (string input in inputs)
      {
         if (input.Length > 70 || ! input.Contains(",")) continue;

         Console.WriteLine(Regex.Escape(input));
         Match match = Regex.Match(input, pattern);
         if (match.Success)
            Console.WriteLine("   Match succeeded.");
         else
            Console.WriteLine("   Match failed.");
      }   
   }
}
// The example displays the following output:
//    Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
//       Match succeeded.
//    Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
//       Match failed.
//    Detroit\ Tigers,\ American\ League,\ 1901-present\n
//       Match failed.
//    New\ York\ Giants,\ National\ League,\ 1885-1957
//       Match succeeded.
//    Washington\ Senators,\ American\ League,\ 1901-1960\r\n
//       Match failed.

Zurück nach oben

Aufeinander folgende Abgleiche: \G

Der \G-Anker gibt an, dass eine Übereinstimmung an dem Punkt auftreten muss, an dem die vorherige Übereinstimmung endete. Wenn Sie diesen Anker mit der Regex.Matches-Methode oder Match.NextMatch-Methode verwenden, wird damit sichergestellt, ob alle Übereinstimmungen zusammenhängend sind.

Im folgenden Beispiel werden die Namen von Nagetierspezies mithilfe eines regulären Ausdrucks aus einer durch Trennzeichen getrennten Zeichenfolge extrahiert.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "capybara,squirrel,chipmunk,porcupine,gopher," + _
                            "beaver,groundhog,hamster,guinea pig,gerbil," + _
                            "chinchilla,prairie dog,mouse,rat"
      Dim pattern As String = "\G(\w+\s?\w*),?"
      Dim match As Match = Regex.Match(input, pattern)
      Do While match.Success
         Console.WriteLine(match.Groups(1).Value)
         match = match.NextMatch()
      Loop 
   End Sub
End Module
' The example displays the following output:
'       capybara
'       squirrel
'       chipmunk
'       porcupine
'       gopher
'       beaver
'       groundhog
'       hamster
'       guinea pig
'       gerbil
'       chinchilla
'       prairie dog
'       mouse
'       rat

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "capybara,squirrel,chipmunk,porcupine,gopher," + 
                     "beaver,groundhog,hamster,guinea pig,gerbil," + 
                     "chinchilla,prairie dog,mouse,rat";
      string pattern = @"\G(\w+\s?\w*),?";
      Match match = Regex.Match(input, pattern);
      while (match.Success) 
      {
         Console.WriteLine(match.Groups[1].Value);
         match = match.NextMatch();
      } 
   }
}
// The example displays the following output:
//       capybara
//       squirrel
//       chipmunk
//       porcupine
//       gopher
//       beaver
//       groundhog
//       hamster
//       guinea pig
//       gerbil
//       chinchilla
//       prairie dog
//       mouse
//       rat

Der reguläre Ausdruck \G(\w+\s?\w*),? wird entsprechend der Darstellung in der folgenden Tabelle interpretiert.

Muster	Beschreibungen
\G	Beginnen Sie da, wo der letzte Abgleich geendet hat.
\w+	Entsprechung für eines oder mehrere Wortzeichen finden.
\s?	Suchen Sie nach einer Übereinstimmung mit 0 (null) oder einem Leerzeichen.
\w*	Suchen Sie nach einer Übereinstimmung mit null oder mehr Wortzeichen.
(\w+\s? \w*)	Suchen Sie nach einer Übereinstimmung mit einem oder mehreren Wortzeichen gefolgt von 0 (null) oder einem Leerzeichen, gefolgt von 0 (null) oder mehr Wortzeichen. Dies ist die erste Erfassungsgruppe.
,?	Suchen Sie nach einer Übereinstimmung mit 0 (null) oder einem Vorkommen eines Literal-Kommazeichens.

Zurück nach oben

Wortgrenze: \b

Der \b-Anker gibt an, dass die Übereinstimmung auf einer Grenze zwischen einem Wortzeichen (dem \w-Sprachelement) und einem Nichtwortzeichen (dem \W-Sprachelement) auftreten muss. Wortzeichen bestehen aus alphanumerischen Zeichen und Unterstrichen. Ein Nichtwortzeichen ist ein nicht alphanumerisches Zeichen und kein Unterstrich. (Weitere Informationen finden Sie unter Zeichenklassen.) Die Übereinstimmung kann auch an einer Wortgrenze am Anfang oder Ende der Zeichenfolge auftreten.

Der \b-Anker wird häufig verwendet, um sicherzustellen, dass ein Teilausdruck einem ganzen Wort statt nur dem Anfang oder Ende eines Worts entspricht. Das folgende Beispiel veranschaulicht die Verwendung des regulären Ausdrucks \bare\w*\b. Findet jedes Wort, das mit der Teilzeichenfolge "are" beginnt. Die Ausgabe des Beispiels veranschaulicht auch, dass \b sowohl mit dem Anfang als auch mit dem Ende der Eingabezeichenfolge übereinstimmt.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "area bare arena mare"
      Dim pattern As String = "\bare\w*\b"
      Console.WriteLine("Words that begin with 'are':")
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("'{0}' found at position {1}", _
                           match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Words that begin with 'are':
'       'area' found at position 0
'       'arena' found at position 10

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "area bare arena mare";
      string pattern = @"\bare\w*\b";
      Console.WriteLine("Words that begin with 'are':");
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("'{0}' found at position {1}",
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       Words that begin with 'are':
//       'area' found at position 0
//       'arena' found at position 10

Das Muster des regulären Ausdrucks wird wie in der folgenden Tabelle gezeigt interpretiert.

Muster	Beschreibungen
\b	Der Vergleich beginnt an einer Wortgrenze.
are	Suchen Sie nach einer Übereinstimmung mit der Teilzeichenfolge "are".
\w*	Suchen Sie nach einer Übereinstimmung mit null oder mehr Wortzeichen.
\b	Der Vergleich endet an einer Wortgrenze.

Zurück nach oben

Non-Word Boundary: \B

Der \B-Anker gibt an, dass die Übereinstimmung nicht an einer Wortgrenze auftreten darf. Dies ist das Gegenteil des \b-Ankers.

Im folgenden Beispiel wird der \B-Anker verwendet, um nach Vorkommen der Teilzeichenfolge "qu" in einem Wort zu suchen. Das Muster \Bqu\w+ des regulären Ausdrucks entspricht einer Teilzeichenfolge, die mit einem "qu" beginnt, kein Wortbeginn ist und bis zum Ende des Worts reicht.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "equity queen equip acquaint quiet"
      Dim pattern As String = "\Bqu\w+"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("'{0}' found at position {1}", _
                           match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       'quity' found at position 1
'       'quip' found at position 14
'       'quaint' found at position 21

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "equity queen equip acquaint quiet";
      string pattern = @"\Bqu\w+";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("'{0}' found at position {1}", 
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       'quity' found at position 1
//       'quip' found at position 14
//       'quaint' found at position 21

Das Muster des regulären Ausdrucks wird wie in der folgenden Tabelle gezeigt interpretiert.

Muster	Beschreibungen
\B	Starten Sie den Abgleich nicht an einer Wortgrenze.
qu	Suchen Sie nach einer Übereinstimmung mit der Teilzeichenfolge "qu".
\w+	Entsprechung für eines oder mehrere Wortzeichen finden.

Zurück nach oben

Siehe auch

Referenz

Optionen für reguläre Ausdrücke

Konzepte

Sprachelemente für reguläre Ausdrücke