Anker in regulären Ausdrücken

Anker, auch als atomische Nullbreitenassertionen bezeichnet, geben eine Position in der Zeichenfolge an, an der eine Übereinstimmung auftreten muss. Wenn Sie einen Anker in Ihrem Suchausdruck verwenden, durchläuft die Engine für reguläre Ausdrücke die Zeichenfolge nicht und verbraucht keine Zeichen; sie sucht nur nach einer Übereinstimmung an der angegebenen Position. Beispielsweise gibt ^ an, dass die Übereinstimmung am Anfang einer Zeile oder Zeichenfolge beginnen muss. Daher entspricht der reguläre Ausdruck ^http: "http:" nur, wenn er am Anfang einer Zeile auftritt. In der folgenden Tabelle sind die Anker aufgeführt, die von den regulären Ausdrücken in .NET unterstützt werden.

Anker	BESCHREIBUNG
^	Die Übereinstimmung muss standardmäßig zu Beginn der Zeichenfolge stattfinden. Im Mehrzeilenmodus muss sie zu Beginn der Zeile erfolgen. Weitere Informationen finden Sie unter Anfang der Zeichenfolge oder Zeile.
$	Standardmäßig muss die Übereinstimmung am Ende der Zeichenfolge oder vor \n dem Ende der Zeichenfolge erfolgen. Im mehrzeiligen Modus muss sie am Ende der Zeile oder vor \n dem Ende der Zeile auftreten. Weitere Informationen finden Sie unter Ende der Zeichenfolge oder Zeile.
\A	Die Übereinstimmung darf nur am Anfang der Zeichenfolge vorliegen (mehrere Zeilen werden nicht unterstützt). Weitere Informationen finden Sie unter Nur Anfang der Zeichenfolge.
\Z	Der Vergleich muss am Ende der Zeichenfolge oder vor \n am Ende der Zeichenfolge erfolgen. Weitere Informationen finden Sie unter Ende der Zeichenfolge oder vor dem abschließenden Zeilenumbruch.
\z	Die Übereinstimmung darf nur am Ende der Zeichenfolge vorliegen. Weitere Informationen finden Sie unter Nur Ende der Zeichenfolge.
\G	Das Match muss an der Position beginnen, an der das vorherige Match beendet wurde, oder wenn es kein vorheriges Match gab, an der Position in der Zeichenfolge, an der das Match gestartet wurde. Weitere Informationen finden Sie unter Benachbarte Übereinstimmungen.
\b	Die Übereinstimmung muss an einer Wortgrenze vorliegen. Weitere Informationen finden Sie unter Word-Grenze.
\B	Die Übereinstimmung darf nicht an einer Wortgrenze vorliegen. Weitere Informationen finden Sie unter "Nicht-Word-Grenze".

Anfang der Zeichenfolge oder Zeile: ^

Standardmäßig gibt der ^ Anker an, dass das folgende Muster an der ersten Zeichenposition der Zeichenfolge beginnen muss. Wenn Sie ^ mit der RegexOptions.Multiline Option verwenden (siehe Optionen für reguläre Ausdrücke), muss die Übereinstimmung am Anfang jeder Zeile erfolgen.

Im folgenden Beispiel wird der ^ Anker in einem regulären Ausdruck verwendet, der Informationen zu den Jahren extrahiert, in denen einige 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 des regulären Ausdrucks übereinstimmt.

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

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        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;

        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(".");
            match = match.NextMatch();
        }
        Console.WriteLine();

        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(".");
            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.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        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

        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(".")
            match = match.NextMatch()
        Loop
        Console.WriteLine()

        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(".")
            match = match.NextMatch()
        Loop
        Console.WriteLine()
    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.

Das Muster ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+ für reguläre Ausdrücke ist wie in der folgenden Tabelle dargestellt definiert.

Muster	BESCHREIBUNG
^	Führen Sie den Abgleich am Anfang der Eingabezeichenfolge durch (oder am Anfang der Zeile, wenn die Methode mit der Option RegexOptions.Multiline aufgerufen wird).
((\w+(\s?)){2,}	Suchen Sie nach einer Übereinstimmung mit mindestens einem Wortzeichen, auf das mindestens zwei Mal eine 0 (Null) oder ein Leerzeichen folgt. Dies ist die erste Erfassungsgruppe. Dieser Ausdruck definiert auch eine zweite und dritte Aufnahmegruppe: Der zweite besteht aus dem erfassten Wort, und der dritte besteht aus dem erfassten Leerraum.
,\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}	Ein Leerzeichen gefolgt von vier Dezimalziffern erkennen.
(-(\d{4}|present))?	Suchen Sie nach einer Übereinstimmung mit 0 (Null) oder einem Bindestrich gefolgt von vier Dezimalzahlen oder der Zeichenfolge "present". Dies ist die sechste Erfassungsgruppe. Diese Gruppe enthält auch eine siebte Erfassungsgruppe.
,?	Suchen Sie nach einer Übereinstimmung mit 0 (null) oder einem Komma.
(\s\d{4}(-(\d{4}|present))?,?)+	Suchen Sie nach einer Übereinstimmung mit mindestens einem Vorkommen der folgenden Elemente: ein Leerzeichen, vier Dezimalzahlen, 0 (Null) oder ein Bindestrich gefolgt von vier Dezimalzahlen oder der Zeichenfolge "present" sowie 0 (Null) oder ein Komma. Dies ist die fünfte Erfassungsgruppe.

Ende der Zeichenfolge oder Zeile: $

Der $ Anker gibt an, dass das vorhergehende Muster am Ende der Eingabezeichenfolge oder vor \n dem Ende der Eingabezeichenfolge erfolgen muss.

Wenn Sie $ mit der RegexOptions.Multiline -Option verwenden, kann die Übereinstimmung auch am Ende einer Zeile vorliegen. Beachten Sie, dass $ mit \n übereinstimmt, nicht jedoch mit \r\n (der Kombination aus Wagenrücklauf- und Zeilenumbruchzeichen oder CR/LF). Um die CR/LF-Zeichenkombination zu behandeln, fügen Sie \r?$ in das Muster für reguläre Ausdrücke ein. Beachten Sie, dass \r?$ alle \r in der Übereinstimmung enthält.

Im folgenden Beispiel wird der $-Anker zum regulären Ausdrucksmuster hinzugefügt, das im Beispiel im Abschnitt "Anfang der Zeichenfolge oder Zeile" verwendet wird. Bei Verwendung mit der ursprünglichen Eingabezeichenfolge, die fünf Textzeilen enthält, kann die Regex.Matches(String, String) Methode keine Übereinstimmung finden, da das Ende der ersten Zeile nicht mit dem $ Muster übereinstimmt. Wenn die ursprüngliche Eingabezeichenfolge in ein Zeichenfolgenarray aufgeteilt wird, gelingt es der Regex.Matches(String, String)-Methode, mit jeder der fünf Zeilen erfolgreich übereinzustimmen. Wenn die Regex.Matches(String, String, RegexOptions)-Methode mit dem auf options festgelegten RegexOptions.Multiline-Parameter aufgerufen wird, werden keine Übereinstimmungen gefunden, da das Wagenrücklaufzeichen \r nicht Teil des Musters des regulären Ausdrucks ist. Wenn das Muster des regulären Ausdrucks jedoch 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.

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        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:");
        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(".");
            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)
        {
            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();

        Console.WriteLine("Attempting to match each line of an input string with '$':");
        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(".");
            match = match.NextMatch();
        }
        Console.WriteLine();

        pattern = basePattern + "\r?$";
        Console.WriteLine(@"Attempting to match each line of an input string with '\r?$':");
        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(".");
            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.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        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:")
        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(".")
            match = match.NextMatch()
        Loop
        Console.WriteLine()

        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
            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()

        Console.WriteLine("Attempting to match each line of an input string with '$':")
        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(".")
            match = match.NextMatch()
        Loop
        Console.WriteLine()

        pattern = basePattern + "\r?$"
        Console.WriteLine("Attempting to match each line of an input string with '\r?$':")
        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(".")

            match = match.NextMatch()
        Loop
        Console.WriteLine()
    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.

Nur Anfang der Zeichenfolge: \A

Der \A Anker gibt an, dass eine Übereinstimmung am Anfang der Eingabezeichenfolge erfolgen muss. Es ist identisch mit dem ^ Anker, außer dass \A die RegexOptions.Multiline Option ignoriert. Daher kann sie nur mit dem Anfang der ersten Zeile in einer mehrzeiligen Eingabezeichenfolge übereinstimmen.

Das folgende Beispiel ähnelt den Beispielen für die ^- und $-Anker. Er verwendet den \A Anker in einem regulären Ausdruck, der Informationen über die Jahre extrahiert, in denen einige professionelle Baseballteams vorhanden waren. Die Eingabezeichenfolge enthält fünf Zeilen. Der Aufruf der Regex.Matches(String, String, RegexOptions) Methode findet nur die erste Teilzeichenfolge in der Eingabezeichenfolge, die dem Muster für reguläre Ausdrücke entspricht. Wie das Beispiel zeigt, hat die Multiline Option keine Auswirkung.

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        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 = 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(".");
            match = match.NextMatch();
        }
        Console.WriteLine();
    }
}
// The example displays the following output:
//    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        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 = 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(".")
            match = match.NextMatch()
        Loop
        Console.WriteLine()
    End Sub
End Module
' The example displays the following output:
'    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.

Ende der Zeichenfolge oder vor dem abschließenden Zeilenumbruch: \Z

Der \Z Anker gibt an, dass eine Übereinstimmung am Ende der Eingabezeichenfolge oder vor \n dem Ende der Eingabezeichenfolge erfolgen muss. Es ist identisch mit dem $ Anker, mit der Ausnahme, dass \Z die RegexOptions.Multiline Option ignoriert. Daher kann dies in einer mehrzeiligen Zeichenfolge nur am Ende der letzten Zeile oder der letzten Zeile vor \n erfüllt werden.

Beachten Sie, dass \Z bei \n erfolgreich ist, aber nicht bei \r\n (die CR/LF-Zeichenkombination). Um CR/LF so zu behandeln, als wäre es \n, schließen Sie \r?\Z in das reguläre Ausdrucksmuster ein. Beachten Sie, dass dies den Teil \r der Übereinstimmung ausmacht.

Im folgenden Beispiel wird der \Z Anker in einem regulären Ausdruck verwendet, der dem Beispiel im Abschnitt "Start of String" oder "Line " ähnelt, der Informationen zu den Jahren extrahiert, in denen einige professionelle Baseballteams vorhanden sind. Der Unterausdruck \r?\Z im regulären Ausdruck ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\Z wird am Ende einer Zeichenfolge und auch am Ende einer Zeichenfolge erfüllt, die mit \n oder \r\nendet. Daher entspricht jedes Element im Array dem Muster für reguläre Ausdrücke.

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)
        {
            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.

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
            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.

Nur Ende der Zeichenfolge: \z

Der \z Anker gibt an, dass eine Übereinstimmung am Ende der Eingabezeichenfolge erfolgen muss. Wie das $ Sprachelement \z ignoriert die RegexOptions.Multiline Option. Im Gegensatz zum Sprachelement \Z wird \z nicht durch ein \n Zeichen am Ende einer Zeichenfolge erfüllt. Daher kann sie nur mit dem Ende der Eingabezeichenfolge übereinstimmen.

Im folgenden Beispiel wird der \z Anker in einem regulären Ausdruck verwendet, der andernfalls mit dem Beispiel im vorherigen Abschnitt identisch ist, das Informationen zu den Jahren extrahiert, in denen einige professionelle Baseballteams vorhanden waren. Im Beispiel wird versucht, eine Übereinstimmung mit dem Muster eines regulären Ausdrucks ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\z für jedes der fünf Elemente in einem Zeichenfolgenarray zu finden. Zwei der Zeichenfolgen enden mit Wagenrücklauf- und Zeilenvorschubzeichen, eine endet mit einem Zeilenvorschubzeichen, und zwei enden weder mit einem Wagenrücklauf- noch mit einem Zeilenvorschubzeichen. Wie die Ausgabe ergibt, stimmen nur die Zeichenfolgen ohne Wagenrücklauf oder Zeilenvorschub mit dem Muster überein.

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\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)
        {
            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.

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
            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.

Aufeinander folgende Übereinstimmungen: \G

Der \G-Anker gibt an, dass eine Übereinstimmung an dem Punkt erfolgen muss, an dem die vorherige Übereinstimmung beendet wurde, oder, wenn keine vorherige Übereinstimmung vorhanden war, an der Position in der Zeichenfolge, an der der Abgleich begonnen hat. Wenn Sie diesen Anchor mit der Regex.Matches -Methode oder Match.NextMatch -Methode verwenden, wird damit sichergestellt, dass alle Übereinstimmungen zusammenhängend sind.

Tipp

In der Regel platzieren Sie einen \G Anker am linken Ende Des Musters. In dem ungewöhnlichen Fall, dass Sie eine Rechts-nach-links-Suche ausführen, platzieren Sie den \G Anker am rechten Ende Ihres Musters.

Im folgenden Beispiel wird ein regulärer Ausdruck verwendet, um die Namen von Nagetierenarten aus einer durch Trennzeichen getrennten Zeichenfolge zu extrahieren.

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

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

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

Muster	BESCHREIBUNG
\G	Beginnen Sie, wo die letzte Partie geendet hat.
\w+	Übereinstimmung mit mindestens einem Wortzeichen.
\s?	Übereinstimmung mit 0 (Null) oder einem Leerzeichen.
\w*	Übereinstimmung mit keinem oder mehreren Wortzeichen.
(\w+\s?\w*)	Übereinstimmung mit mindestens einem Wortzeichen gefolgt von 0 (Null) oder einem Leerzeichen, gefolgt von 0 (Null) oder weiteren Wortzeichen. Dies ist die erste Erfassungsgruppe.
,?	Übereinstimmung mit 0 (Null) oder einem Literal-Kommazeichen.

Wortgrenze: \b

Der \b Anker gibt an, dass die Übereinstimmung auf einer Grenze zwischen einem Wortzeichen (dem \w Sprachelement) und einem Nicht-Wort-Zeichen (dem \W Sprachelement) erfolgen muss. Word-Zeichen bestehen aus alphanumerischen Zeichen und Unterstrichen; Ein Nicht-Wort-Zeichen ist ein beliebiges Zeichen, das nicht alphanumerisch oder unterstrich ist. (Weitere Informationen finden Sie unter Zeichenklassen.) Die Übereinstimmung kann auch an einer Wortgrenze am Anfang oder Ende des Strings auftreten.

Der \b Anker wird häufig verwendet, um sicherzustellen, dass ein Unterausdruck einem ganzen Wort und nicht nur dem Anfang oder Ende eines Worts entspricht. Der reguläre Ausdruck \bare\w*\b im folgenden Beispiel veranschaulicht diese Verwendung. Es entspricht jedem Wort, das mit der Teilzeichenfolge "are" beginnt. Die Ausgabe aus dem Beispiel veranschaulicht auch, dass \b sowohl dem Anfang als auch dem Ende der Eingabezeichenfolge entspricht.

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($"'{match.Value}' found at position {match.Index}");
    }
}
// The example displays the following output:
//       Words that begin with 'are':
//       'area' found at position 0
//       'arena' found at position 10

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

Das Muster für reguläre Ausdrücke wird entsprechend der folgenden Tabelle interpretiert.

Muster	BESCHREIBUNG
\b	Der Vergleich beginnt an einer Wortgrenze.
are	Übereinstimmung mit der Teilzeichenfolge "are".
\w*	Übereinstimmung mit keinem oder mehreren Wortzeichen.
\b	Der Vergleich endet an einer Wortgrenze.

Nicht-Wortgrenze: \B

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

Im folgenden Beispiel wird der \B Anker verwendet, um Vorkommen der Teilzeichenfolge "qu" in einem Wort zu finden. Das Muster \Bqu\w+ für reguläre Ausdrücke entspricht einer Teilzeichenfolge, die mit einem "qu" beginnt, das kein Wort beginnt und das am Ende des Worts fortgesetzt wird.

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($"'{match.Value}' found at position {match.Index}");
    }
}
// The example displays the following output:
//       'quity' found at position 1
//       'quip' found at position 14
//       'quaint' found at position 21

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

Das Muster für reguläre Ausdrücke wird entsprechend der folgenden Tabelle interpretiert.

Muster	BESCHREIBUNG
\B	Übereinstimmung beginnt nicht an einer Wortgrenze.
qu	Übereinstimmung mit der Teilzeichenfolge "qu".
\w+	Übereinstimmung mit mindestens einem Wortzeichen.

Siehe auch

• Sprachelemente für reguläre Ausdrücke – Kurzübersicht
• Optionen für reguläre Ausdrücke