Zakotwiczenia w wyrażeniach regularnych

Kotwice lub niepodzielne aseracje o zerowej szerokości określają pozycję w ciągu, w którym musi wystąpić dopasowanie. Jeśli używasz kotwicy w wyrażeniu wyszukiwania, aparat wyrażeń regularnych nie przechodzi przez ciąg ani nie używa znaków; szuka dopasowania tylko w określonej pozycji. Na przykład określa, ^ że dopasowanie musi rozpoczynać się na początku wiersza lub ciągu. W związku z tym wyrażenie ^http: regularne jest zgodne z ciągiem "http:" tylko wtedy, gdy występuje na początku wiersza. W poniższej tabeli wymieniono kotwice obsługiwane przez wyrażenia regularne na platformie .NET.

Kotwica	opis
^	Domyślnie dopasowanie musi występować na początku ciągu; w trybie wielowierszowym musi występować na początku wiersza. Aby uzyskać więcej informacji, zobacz Początek ciągu lub wiersza.
$	Domyślnie dopasowanie musi występować na końcu ciągu lub przed \n końcem ciągu; w trybie wielowierszowym musi występować na końcu wiersza lub przed \n końcem wiersza. Aby uzyskać więcej informacji, zobacz Koniec ciągu lub wiersza.
\A	Dopasowanie musi występować tylko na początku ciągu (bez obsługi wielowierszowej). Aby uzyskać więcej informacji, zobacz Start of String Only (Tylko początek ciągu).
\Z	Dopasowanie musi występować na końcu ciągu lub przed \n końcem ciągu. Aby uzyskać więcej informacji, zobacz Koniec ciągu lub Przed zakończeniem nowego wiersza.
\z	Dopasowanie musi występować tylko na końcu ciągu. Aby uzyskać więcej informacji, zobacz Tylko koniec ciągu.
\G	Dopasowanie musi zaczynać się od pozycji, w której zakończyło się poprzednie dopasowanie lub jeśli nie było poprzedniego dopasowania, na pozycji w ciągu, w którym rozpoczęto dopasowywanie. Aby uzyskać więcej informacji, zobacz Ciągłe dopasowania.
\b	Dopasowanie musi występować na granicy słowa. Aby uzyskać więcej informacji, zobacz Granica programu Word.
\B	Dopasowanie nie może występować na granicy słowa. Aby uzyskać więcej informacji, zobacz Granica niezwiązana z wyrazami.

Początek ciągu lub wiersz: ^

Domyślnie kotwica określa, ^ że następujący wzorzec musi zaczynać się od pierwszego znaku pozycji ciągu. Jeśli używasz ^ z opcją RegexOptions.Multiline (zobacz Opcje wyrażeń regularnych), dopasowanie musi nastąpić na początku każdego wiersza.

W poniższym przykładzie ^ użyto kotwicy w wyrażeniu regularnym, które wyodrębnia informacje o latach, w których istniały niektóre profesjonalne drużyny baseballowe. W przykładzie Regex.Matches wywoływane są dwa przeciążenia metody:

• Wywołanie Matches(String, String) przeciążenia znajduje tylko pierwszy podciąg w ciągu wejściowym, który pasuje do wzorca wyrażenia regularnego.

• Wywołanie Matches(String, String, RegexOptions) przeciążenia z ustawionym parametrem options w celu RegexOptions.Multiline znalezienia wszystkich pięciu podciągów.

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.

Wzorzec ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+ wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.

Wzorzec	opis
^	Rozpocznij dopasowanie na początku ciągu wejściowego (lub początek wiersza, jeśli metoda jest wywoływana z opcją RegexOptions.Multiline ).
((\w+(\s?)){2,}	Dopasuj co najmniej jeden znak słowa, po którym następuje zero lub jedną spację co najmniej dwa razy. Jest to pierwsza grupa przechwytywania. To wyrażenie definiuje również drugą i trzecią grupę przechwytywania: drugi składa się z przechwyconego słowa, a trzeci składa się z przechwyconego odstępu.
,\s	Dopasuj przecinek, po którym następuje znak odstępu.
(\w+\s\w+)	Dopasuj co najmniej jeden znak wyrazu, po którym następuje spacja, po którym następuje co najmniej jeden znak słowa. Jest to czwarta grupa przechwytywania.
,	Dopasuj przecinek.
\s\d{4}	Dopasuj spację, po której następują cztery cyfry dziesiętne.
(-(\d{4}|present))?	Dopasuj zero lub jedno wystąpienie łącznika, po którym następują cztery cyfry dziesiętne lub ciąg "present". Jest to szósta grupa przechwytywania. Obejmuje również siódmą grupę przechwytywania.
,?	Dopasuj zero lub jedno wystąpienie przecinka.
(\s\d{4}(-(\d{4}|present))?,?)+	Dopasuj co najmniej jedno wystąpienie następujących wystąpień: spację, cztery cyfry dziesiętne, zero lub jedno wystąpienie łącznika, po którym następują cztery cyfry dziesiętne lub ciąg "present" i zero lub jeden przecinek. Jest to piąta grupa przechwytywania.

Koniec ciągu lub linii: $

Kotwica $ określa, że poprzedni wzorzec musi występować na końcu ciągu wejściowego lub przed \n na końcu ciągu wejściowego.

Jeśli używasz $ z opcją RegexOptions.Multiline , dopasowanie może również wystąpić na końcu wiersza. Należy pamiętać, że $ jest spełniony, \n ale nie \r\n w (kombinacja znaków powrotu karetki i znaków nowego wiersza lub CR/LF). Aby obsłużyć kombinację znaków CR/LF, uwzględnij \r?$ element we wzorcu wyrażenia regularnego. Należy pamiętać, że \r?$ będzie zawierać dowolny \r element w dopasowaniu.

Poniższy przykład dodaje kotwicę $ do wzorca wyrażenia regularnego używanego w przykładzie w sekcji Początek ciągu lub wiersza . W przypadku użycia z oryginalnym ciągiem wejściowym, który zawiera pięć wierszy tekstu, Regex.Matches(String, String) metoda nie może odnaleźć dopasowania, ponieważ koniec pierwszego wiersza nie jest zgodny ze $ wzorcem. Gdy oryginalny ciąg wejściowy jest podzielony na tablicę ciągów, Regex.Matches(String, String) metoda kończy się powodzeniem w dopasowywaniu każdego z pięciu wierszy. Gdy metoda jest wywoływana Regex.Matches(String, String, RegexOptions) z parametrem ustawionym options na RegexOptions.Multiline, nie znaleziono dopasowań, ponieważ wzorzec wyrażenia regularnego nie uwzględnia znaku \rpowrotu karetki . Jednak gdy wzorzec wyrażenia regularnego zostanie zmodyfikowany przez zastąpienie wartością \r?$, wywołaj $Regex.Matches(String, String, RegexOptions) metodę za pomocą parametru ustawionego options na wartość , aby RegexOptions.Multiline ponownie znaleźć pięć dopasowań.

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.

Tylko początek ciągu: \A

Kotwica \A określa, że dopasowanie musi wystąpić na początku ciągu wejściowego. Jest on identyczny z kotwicą ^ , z tą różnicą, że \A ignoruje RegexOptions.Multiline opcję . W związku z tym może on być zgodny tylko z rozpoczęciem pierwszego wiersza w ciągu wejściowym wielowierszowym.

Poniższy przykład jest podobny do przykładów dla ^ kotwic i $ . Używa kotwicy w wyrażeniu \A regularnym, który wyodrębnia informacje o latach, w których istniały niektóre profesjonalne drużyny baseballowe. Ciąg wejściowy zawiera pięć wierszy. Wywołanie Regex.Matches(String, String, RegexOptions) metody znajduje tylko pierwszy podciąg w ciągu wejściowym zgodnym ze wzorcem wyrażenia regularnego. Jak pokazano w przykładzie, Multiline opcja nie ma wpływu.

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.

Koniec ciągu lub przed zakończeniem nowego wiersza: \Z

Kotwica \Z określa, że dopasowanie musi wystąpić na końcu ciągu wejściowego lub przed \n na końcu ciągu wejściowego. Jest on identyczny z kotwicą $ , z tą różnicą, że \Z ignoruje RegexOptions.Multiline opcję . W związku z tym w ciągu wielowierszowym można go spełnić tylko na końcu ostatniego wiersza lub ostatniego wiersza przed \n.

Należy pamiętać, że \Z jest spełniony, \n ale nie jest spełniony w \r\n (kombinacja znaków CR/LF). Aby traktować cr/LF tak, jakby to było \n, uwzględnij \r?\Z we wzorcu wyrażenia regularnego. Należy pamiętać, że będzie \r to część dopasowania.

W poniższym przykładzie użyto \Z kotwicy w wyrażeniu regularnym, które jest podobne do przykładu w sekcji Początek ciągu lub linii , która wyodrębnia informacje o latach, w których istniały niektóre profesjonalne drużyny baseballowe. Podexpression \r?\Z w wyrażeniu regularnym ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\Z jest spełniony na końcu ciągu, a także na końcu ciągu kończącego się ciągiem \n lub \r\n. W rezultacie każdy element w tablicy jest zgodny ze wzorcem wyrażenia regularnego.

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.

Tylko koniec ciągu: \z

Kotwica \z określa, że dopasowanie musi wystąpić na końcu ciągu wejściowego. $ Podobnie jak element języka, \z ignoruje RegexOptions.Multiline opcję . \Z W przeciwieństwie do elementu języka, \z nie jest spełniony przez \n znak na końcu ciągu. W związku z tym może on być zgodny tylko z końcem ciągu wejściowego.

W poniższym przykładzie użyto \z kotwicy w wyrażeniu regularnym, które jest inaczej identyczne z przykładem w poprzedniej sekcji, która wyodrębnia informacje o latach, w których istniały niektóre profesjonalne drużyny baseballowe. Przykład próbuje dopasować każdy z pięciu elementów w tablicy ciągów ze wzorcem ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\zwyrażenia regularnego . Dwa ciągi kończą się znakiem powrotu karetki i znakiem przesuwu wiersza, jeden kończy się znakiem przesuwu wiersza, a dwa kończą się ani znakiem powrotu karetki, ani znakiem przesuwu wiersza. Jak pokazują dane wyjściowe, tylko ciągi bez znaku powrotu karetki lub znaku kanału informacyjnego są zgodne ze wzorcem.

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.

Ciągłe dopasowanie: \G

Kotwica \G określa, że dopasowanie musi wystąpić w punkcie, w którym zakończyło się poprzednie dopasowanie, lub jeśli nie było poprzedniego dopasowania, na pozycji w ciągu, w którym rozpoczęto dopasowywanie. Jeśli używasz tej kotwicy z Regex.Matches metodą or Match.NextMatch , gwarantuje, że wszystkie dopasowania są ciągłe.

Napiwek

Zazwyczaj na lewym końcu wzorca umieszcza się kotwicę \G . W rzadkim przypadku przeprowadzania wyszukiwania od prawej do lewej umieść kotwicę \G na prawym końcu wzorca.

W poniższym przykładzie użyto wyrażenia regularnego do wyodrębnienia nazw gatunków gryzoni z ciągu rozdzielanego przecinkami.

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

Wyrażenie \G(\w+\s?\w*),? regularne jest interpretowane, jak pokazano w poniższej tabeli.

Wzorzec	opis
\G	Rozpocznij, gdzie zakończyło się ostatnie dopasowanie.
\w+	Dopasowuje co najmniej jeden znak słowa.
\s?	Dopasuj zero lub jedną spację.
\w*	Dopasowuje zero lub więcej znaków słowa.
(\w+\s?\w*)	Dopasuj co najmniej jeden znak słowa, po którym następuje zero lub jedną spację, po której następuje zero lub więcej znaków wyrazów. Jest to pierwsza grupa przechwytywania.
,?	Dopasuj zero lub jedno wystąpienie znaku przecinka literału.

Wyszukiwanie granicy wyrazów: \b

Kotwica \b określa, że dopasowanie musi występować na granicy między znakiem słowa ( \w elementem języka) i znakiem niezwiązanym ( \W elementem języka). Znaki programu Word składają się z znaków alfanumerycznych i podkreśleń; znak inny niż wyraz to dowolny znak, który nie jest alfanumeryczny lub podkreślenie. (Aby uzyskać więcej informacji, zobacz Klasy znaków). Dopasowanie może również wystąpić na granicy wyrazu na początku lub na końcu ciągu.

Kotwica \b jest często używana w celu zapewnienia, że podwyrażenie pasuje do całego wyrazu zamiast tylko początku lub końca wyrazu. Wyrażenie regularne \bare\w*\b w poniższym przykładzie ilustruje to użycie. Pasuje do dowolnego wyrazu rozpoczynającego się od podciągu "are". Dane wyjściowe z przykładu ilustrują również, że \b są zgodne zarówno z początkiem, jak i końcem ciągu wejściowego.

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

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

Wzorzec wyrażenia regularnego jest interpretowany, jak pokazano w poniższej tabeli.

Wzorzec	opis
\b	Rozpoczyna dopasowanie na granicy wyrazu.
are	Dopasuj podciąg "are".
\w*	Dopasowuje zero lub więcej znaków słowa.
\b	Kończy dopasowanie na granicy wyrazu.

Brak wyszukiwania granicy wyrazów: \B

Kotwica \B określa, że dopasowanie nie może występować na granicy słowa. Jest to przeciwieństwo \b kotwicy.

W poniższym przykładzie użyto \B kotwicy w celu zlokalizowania wystąpień podciągów "qu" w słowie. Wzorzec \Bqu\w+ wyrażenia regularnego jest zgodny z podciągem rozpoczynającym się od ciągu "qu", który nie rozpoczyna słowa i który jest kontynuowany na końcu słowa.

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

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

Wzorzec wyrażenia regularnego jest interpretowany, jak pokazano w poniższej tabeli.

Wzorzec	opis
\B	Nie należy rozpoczynać dopasowania na granicy słowa.
qu	Dopasuj podciąg "qu".
\w+	Dopasowuje co najmniej jeden znak słowa.

Zobacz też

• Język wyrażeń regularnych — podręczny wykaz
• Opcje wyrażeń regularnych