Zakotwiczenia w wyrażeniach regularnychAnchors in Regular Expressions

Kotwice lub atomic asercjami o zerowej szerokości, należy określić pozycja w ciągu, w którym dopasowanie musi wystąpić.Anchors, or atomic zero-width assertions, specify a position in the string where a match must occur. Korzystając z elementu zakotwiczenia w wyrażeniu wyszukiwania, aparat wyrażeń regularnych nie przechodzi ciągu lub używa znaków; Wyszukuje dopasowania w określonej pozycji.When you use an anchor in your search expression, the regular expression engine does not advance through the string or consume characters; it looks for a match in the specified position only. Na przykład ^ Określa, że dopasowanie musi rozpoczynać się na początku wiersza lub ciągu.For example, ^ specifies that the match must start at the beginning of a line or string. W związku z tym, wyrażenie regularne ^http: pasuje do "http:" tylko wtedy, gdy wystąpi go na początku wiersza.Therefore, the regular expression ^http: matches "http:" only when it occurs at the beginning of a line. W poniższej tabeli wymieniono kotwic obsługiwane przez wyrażenia regularne w .NET.The following table lists the anchors supported by the regular expressions in .NET.

KotwicaAnchor OpisDescription
^ Domyślnie dopasowanie musi wystąpić na początku ciągu; w tryb wielowierszowy musi wystąpić na początku wiersza.By default, the match must occur at the beginning of the string; in multiline mode, it must occur at the beginning of the line. Aby uzyskać więcej informacji, zobacz Start ciągu lub linii.For more information, see Start of String or Line.
$ Domyślnie dopasowanie musi wystąpić na końcu ciągu lub przed \n na końcu ciągu; w tryb wielowierszowy musi wystąpić na końcu linii lub przed \n na końcu wiersza.By default, the match must occur at the end of the string or before \n at the end of the string; in multiline mode, it must occur at the end of the line or before \n at the end of the line. Aby uzyskać więcej informacji, zobacz koniec ciągu lub linii.For more information, see End of String or Line.
\A Dopasowanie musi wystąpić na początku tylko ciągi (bez obsługi wielowierszowy).The match must occur at the beginning of the string only (no multiline support). Aby uzyskać więcej informacji, zobacz Start z ciągu tylko.For more information, see Start of String Only.
\Z Dopasowanie musi wystąpić na końcu ciągu lub przed \n na końcu ciągu.The match must occur at the end of the string, or before \n at the end of the string. Aby uzyskać więcej informacji, zobacz koniec ciągu lub przed Kończenie znakami nowego wiersza.For more information, see End of String or Before Ending Newline.
\z Dopasowanie musi wystąpić na końcu tylko ciągi.The match must occur at the end of the string only. Aby uzyskać więcej informacji, zobacz zakończenia z ciągu tylko.For more information, see End of String Only.
\G Dopasowanie musi rozpoczynać się w miejscu, gdzie kończy się poprzednie dopasowanie.The match must start at the position where the previous match ended. Aby uzyskać więcej informacji, zobacz ciągłe.For more information, see Contiguous Matches.
\b Dopasowanie musi wystąpić na granicy wyrazu.The match must occur on a word boundary. Aby uzyskać więcej informacji, zobacz granicy słowa.For more information, see Word Boundary.
\B Dopasowanie nie musi wystąpić na granicy wyrazu.The match must not occur on a word boundary. Aby uzyskać więcej informacji, zobacz granicy słowa inne niż.For more information, see Non-Word Boundary.

Początek ciągu lub wiersz: ^Start of String or Line: ^

Domyślnie ^ zakotwiczenia określa, że następujący wzorzec musi rozpoczynać się od pierwszego pozycji znaku w ciągu.By default, the ^ anchor specifies that the following pattern must begin at the first character position of the string. Jeśli używasz ^ z RegexOptions.Multiline opcji (zobacz Regular Expression Options), dopasowanie musi wystąpić na początku każdego wiersza.If you use ^ with the RegexOptions.Multiline option (see Regular Expression Options), the match must occur at the beginning of each line.

W poniższym przykładzie użyto ^ zakotwiczenia w wyrażeniach regularnych, która wyodrębnia informacje o lat, podczas których niektóre zespoły profesjonalnych mecz istniał.The following example uses the ^ anchor in a regular expression that extracts information about the years during which some professional baseball teams existed. Przykład wywołuje dwa przeciążenia metody Regex.Matches metody:The example calls two overloads of the Regex.Matches method:

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

Definicję wzorca wyrażenia regularnego ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+ jest zdefiniowany jak pokazano w poniższej tabeli.The regular expression pattern ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+ is defined as shown in the following table.

WzorzecPattern OpisDescription
^ Dopasowanie musi przypadać na początku ciągu wejściowego (lub na początku wiersza, jeśli metoda jest wywoływana z RegexOptions.Multiline opcji).Begin the match at the beginning of the input string (or the beginning of the line if the method is called with the RegexOptions.Multiline option).
((\w+(\s?)){2,} Dopasowuje co najmniej jeden znak słowa, a następnie przez zero lub jedną spację dokładnie dwa razy.Match one or more word characters followed either by zero or by one space exactly two times. Jest to pierwsza grupa przechwytywania.This is the first capturing group. To wyrażenie definiuje również druga i trzecia grupa przechwytywania: Drugi składa się z przechwyconych programu word, a trzeci składa się z przechwyconych miejsca do magazynowania.This expression also defines a second and third capturing group: The second consists of the captured word, and the third consists of the captured spaces.
,\s Dopasowuje przecinek następuje znak odstępu.Match a comma followed by a white-space character.
(\w+\s\w+) Dopasowuje co najmniej jeden znak słowa, spację, następuje jeden lub więcej znaków słowa.Match one or more word characters followed by a space, followed by one or more word characters. Jest to czwarty grupa przechwytywania.This is the fourth capturing group.
, Odpowiada wartości przecinkami.Match a comma.
\s\d{4} Dopasowanie do miejsca, następuje czterem cyfrom po przecinku.Match a space followed by four decimal digits.
(-(\d{4}|present))? Dopasowuje zero lub jeden wystąpienie łącznika następują cztery cyfry dziesiętne lub ciąg "obecne".Match zero or one occurrence of a hyphen followed by four decimal digits or the string "present". To jest szóstego grupa przechwytywania.This is the sixth capturing group. Zawiera on również siódmego grupa przechwytywania.It also includes a seventh capturing group.
,? Wystąpienie Dopasuj zero lub jeden przecinek.Match zero or one occurrence of a comma.
(\s\d{4}(-(\d{4}|present))?,?)+ Zgodne z co najmniej jedno z następujących czynności: spację, czterem cyfrom po przecinku, zera lub jednego wystąpienia z łącznikiem następuje czterem cyfrom po przecinku lub ciąg "obecny" oraz zero lub jeden przecinek.Match one or more occurrences of the following: a space, four decimal digits, zero or one occurrence of a hyphen followed by four decimal digits or the string "present", and zero or one comma. Jest to piąty grupa przechwytywania.This is the fifth capturing group.

Powrót do początkuBack to top

Koniec ciągu lub linii: $End of String or Line: $

$ Zakotwiczenia określa, że poprzedni wzorzec musi wystąpić na końcu ciągu wejściowego lub przed \n na końcu ciągu wejściowego.The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string.

Jeśli używasz $ z RegexOptions.Multiline opcję dopasowanie może również wystąpić na końcu wiersza.If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. Należy pamiętać, że $ odpowiada \n , ale nie pasuje \r\n (kombinację karetki return i znaki nowego wiersza lub CR/LF).Note that $ matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). Aby dopasować kombinacji znaków CR/LF, obejmują \r?$ we wzorcu wyrażenia regularnego.To match the CR/LF character combination, include \r?$ in the regular expression pattern.

W poniższym przykładzie dodano $ kotwicy na wzorcu wyrażenia regularnego użytego w przykładzie w Start ciągu lub linii sekcji.The following example adds the $ anchor to the regular expression pattern used in the example in the Start of String or Line section. Gdy jest używane z oryginalnego ciągu wejściowego, który zawiera pięć wierszy tekstu, Regex.Matches(String, String) — metoda nie może odnaleźć dopasowania, ponieważ nie są zgodne w końcu pierwszego wiersza $ wzorca.When used with the original input string, which includes five lines of text, the Regex.Matches(String, String) method is unable to find a match, because the end of the first line does not match the $ pattern. Gdy oryginalny ciąg wejściowy jest podzielony na tablicę ciągów, Regex.Matches(String, String) metoda zakończy się pomyślnie w dopasowywania wszystkich pięciu wierszach.When the original input string is split into a string array, the Regex.Matches(String, String) method succeeds in matching each of the five lines. Gdy Regex.Matches(String, String, RegexOptions) metoda jest wywoływana z options parametr RegexOptions.Multiline, nie znaleziono żadnych dopasowań, ponieważ wzorzec wyrażenia regularnego nie uwzględniać return elementu powrotu karetki (\u+000D).When the Regex.Matches(String, String, RegexOptions) method is called with the options parameter set to RegexOptions.Multiline, no matches are found because the regular expression pattern does not account for the carriage return element (\u+000D). Jednak, gdy wzorzec wyrażenia regularnego jest modyfikowany przez zastąpienie $ z \r?$, wywoływania Regex.Matches(String, String, RegexOptions) metody z options parametr RegexOptions.Multiline ponownie znajduje się pięć dopasowań.However, when the regular expression pattern is modified by replacing $ with \r?$, calling the Regex.Matches(String, String, RegexOptions) method with the options parameter set to RegexOptions.Multiline again finds five matches.

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

Powrót do początkuBack to top

Tylko początek ciągu: \AStart of String Only: \A

\A Zakotwiczenia określa, że dopasowanie musi wystąpić na początku ciągu wejściowego.The \A anchor specifies that a match must occur at the beginning of the input string. Jest on identyczny ^ zakotwiczyć, chyba że \A ignoruje RegexOptions.Multiline opcji.It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. W związku z tym może wyłącznie odpowiadać początek pierwszy wiersz w wielowierszowy ciąg wejściowy.Therefore, it can only match the start of the first line in a multiline input string.

Poniższy przykład jest podobny do przykładów dla ^ i $ zakotwiczenia.The following example is similar to the examples for the ^ and $ anchors. Używa ona \A zakotwiczenia w wyrażeniach regularnych, która wyodrębnia informacje o lat, podczas których niektóre zespoły profesjonalnych mecz istniał.It uses the \A anchor in a regular expression that extracts information about the years during which some professional baseball teams existed. Ciąg wejściowy zawiera pięć wierszy.The input string includes five lines. Wywołanie Regex.Matches(String, String, RegexOptions) metoda znajdzie pierwszego podciągu w ciągu wejściowym, który pasuje do wzorca wyrażenia regularnego.The call to the Regex.Matches(String, String, RegexOptions) method finds only the first substring in the input string that matches the regular expression pattern. Jak pokazano w przykładzie Multiline opcja nie ma wpływu.As the example shows, the Multiline option has no effect.

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

Powrót do początkuBack to top

Koniec ciągu lub przed zakończeniem nowego wiersza: \ZEnd of String or Before Ending Newline: \Z

\Z Zakotwiczenia określa, że dopasowanie musi wystąpić na końcu ciągu wejściowego lub przed \n na końcu ciągu wejściowego.The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. Jest on identyczny $ zakotwiczyć, chyba że \Z ignoruje RegexOptions.Multiline opcji.It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. W związku z tym, w wielowierszowy ciąg je mogą tylko odnosić się do końca ostatni wiersz lub ostatni wiersz przed \n.Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n.

Należy pamiętać, że \Z odpowiada \n , ale nie pasuje \r\n (kombinacji znaków CR/LF).Note that \Z matches \n but does not match \r\n (the CR/LF character combination). Aby dopasować CR/LF, obejmują \r?\Z we wzorcu wyrażenia regularnego.To match CR/LF, include \r?\Z in the regular expression pattern.

W poniższym przykładzie użyto \Z zakotwiczenia w wyrażeniach regularnych, która jest podobna do przykładu w Start ciągu lub linii sekcji, która wyodrębnia informacje o lat, podczas której niektóre mecz professional zespoły istniał.The following example uses the \Z anchor in a regular expression that is similar to the example in the Start of String or Line section, which extracts information about the years during which some professional baseball teams existed. Podwyrażenie \r?\Z w wyrażeniu regularnym ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\Z pasuje do końca ciągu, a także pasuje do ciągu, która kończy się \n lub \r\n.The subexpression \r?\Z in the regular expression ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\Z matches the end of a string, and also matches a string that ends with \n or \r\n. W rezultacie każdy element w tablicy pasuje do wzorca wyrażenia regularnego.As a result, each element in the array matches the regular expression pattern.

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

Powrót do początkuBack to top

Tylko koniec ciągu: \zEnd of String Only: \z

\z Zakotwiczenia określa, że dopasowanie musi wystąpić na końcu ciągu wejściowego.The \z anchor specifies that a match must occur at the end of the input string. Podobnie jak $ element języka \z ignoruje RegexOptions.Multiline opcji.Like the $ language element, \z ignores the RegexOptions.Multiline option. W odróżnieniu od \Z element języka \z nie odpowiada \n znak na końcu ciągu.Unlike the \Z language element, \z does not match a \n character at the end of a string. W związku z tym może wyłącznie odpowiadać ostatni wiersz w ciągu wejściowym.Therefore, it can only match the last line of the input string.

W poniższym przykładzie użyto \z zakotwiczenia w wyrażeniach regularnych, które w przeciwnym razie jest taka sama jak w przykładzie w poprzedniej sekcji, która wyodrębnia informacje o lat, podczas których niektóre zespoły profesjonalnych mecz istniał.The following example uses the \z anchor in a regular expression that is otherwise identical to the example in the previous section, which extracts information about the years during which some professional baseball teams existed. Przykład podejmuje próbę dopasowania wszystkich pięć kolejnych elementów w tablicy ciągów z wzorcem wyrażenia regularnego ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\z.The example tries to match each of five elements in a string array with the regular expression pattern ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\z. Zwraca dwa ciągi kończyć powrotu karetki i znaki wysuwu wiersza, zakończy się znak nowego wiersza i zwraca karetki ani kończyć się w dwóch ani znak wysuwu wiersza.Two of the strings end with carriage return and line feed characters, one ends with a line feed character, and two end with neither a carriage return nor a line feed character. Dane wyjściowe pokazują, zwracać tylko ciągi bez znaków powrotu karetki lub wysuwu wiersza dopasowania znaku wzorca.As the output shows, only the strings without a carriage return or line feed character match the pattern.

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

Powrót do początkuBack to top

Ciągłe dopasowanie: \GContiguous Matches: \G

\G Zakotwiczenia określa, że dopasowanie musi wystąpić w punkcie, w którym kończy się poprzednie dopasowanie.The \G anchor specifies that a match must occur at the point where the previous match ended. Kiedy używać tego zakotwiczenia z Regex.Matches lub Match.NextMatch metody go gwarantuje, że wszystkie dopasowania będą ciągłe.When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous.

W poniższym przykładzie użyto wyrażenia regularnego można wyodrębnić nazwy gryzonia gatunków z ciągów rozdzielanych przecinkami.The following example uses a regular expression to extract the names of rodent species from a comma-delimited string.

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 regularne \G(\w+\s?\w*),? jest interpretowane tak jak pokazano w poniższej tabeli.The regular expression \G(\w+\s?\w*),? is interpreted as shown in the following table.

WzorzecPattern OpisDescription
\G Rozpocznij, gdzie zakończenia ostatniego dopasowania.Begin where the last match ended.
\w+ Dopasowuje co najmniej jeden znak słowa.Match one or more word characters.
\s? Dopasowanie do zera lub jednego miejsca.Match zero or one space.
\w* Dopasowuje zero lub więcej znaków słowa.Match zero or more word characters.
(\w+\s?\w*) Dopasowuje co najmniej jeden znak słowa, następuje zero lub jeden miejsce, w którym następuje zero lub więcej znaków słowa.Match one or more word characters followed by zero or one space, followed by zero or more word characters. Jest to pierwsza grupa przechwytywania.This is the first capturing group.
,? Wystąpienie Dopasuj zero lub jeden znak przecinka literału.Match zero or one occurrence of a literal comma character.

Powrót do początkuBack to top

Wyszukiwanie granicy wyrazów: \bWord Boundary: \b

\b Zakotwiczenia określa, że dopasowanie musi wystąpić na granicy między znakiem słowa ( \w element języka) i znaki niebędące znakami słowa ( \W element języka).The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Znak słowa zawierać znaki alfanumeryczne i znaki podkreślenia; znaki niebędące znakami słowa jest dowolny znak, który nie jest alfanumerycznym lub znakiem podkreślenia.Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. (Aby uzyskać więcej informacji, zobacz klas znaków.) Dopasowanie może również wystąpić na granicy słowa na początku lub na końcu ciągu.(For more information, see Character Classes.) The match may also occur on a word boundary at the beginning or end of the string.

\b Zakotwiczenia jest często używany do upewnij się, że wyrażenie cząstkowe odpowiada całe wyrazy, a nie tylko początek lub koniec wyrazu.The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. Wyrażenie regularne \bare\w*\b w poniższym przykładzie przedstawiono użycie tych.The regular expression \bare\w*\b in the following example illustrates this usage. Dopasowuje dowolny wyraz rozpoczynający się od podciągu "czy".It matches any word that begins with the substring "are". Dane wyjściowe z przykładu, ilustruje \b pasuje do początku i na końcu ciągu wejściowego.The output from the example also illustrates that \b matches both the beginning and the end of the input string.

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.The regular expression pattern is interpreted as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
are Dopasuj podciąg "czy".Match the substring "are".
\w* Dopasowuje zero lub więcej znaków słowa.Match zero or more word characters.
\b Kończy dopasowanie na granicy wyrazu.End the match at a word boundary.

Powrót do początkuBack to top

Brak wyszukiwania granicy wyrazów: \BNon-Word Boundary: \B

\B Zakotwiczenia określa, że dopasowanie nie musi wystąpić na granicy wyrazu.The \B anchor specifies that the match must not occur on a word boundary. Jest to odwrotność \b zakotwiczenia.It is the opposite of the \b anchor.

W poniższym przykładzie użyto \B kontrolne, aby zlokalizować wystąpienia podciągu "kwerendy" w wyrazie.The following example uses the \B anchor to locate occurrences of the substring "qu" in a word. Definicję wzorca wyrażenia regularnego \Bqu\w+ pasuje do podciągu, który rozpoczyna się od "kwerendy", nie uruchamia program word i która kontynuuje do końca słowa.The regular expression pattern \Bqu\w+ matches a substring that begins with a "qu" that does not start a word and that continues to the end of the word.

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.The regular expression pattern is interpreted as shown in the following table.

WzorzecPattern OpisDescription
\B Nie rozpoczyna dopasowanie na granicy wyrazu.Do not begin the match at a word boundary.
qu Dopasuj podciąg "kwerendy".Match the substring "qu".
\w+ Dopasowuje co najmniej jeden znak słowa.Match one or more word characters.

Zobacz takżeSee also