Opcje wyrażeń regularnychRegular Expression Options

Domyślnie porównanie ciągu wejściowego z dowolnymi literałami we wzorcu wyrażenia regularnego jest uwzględniana wielkość liter, biały znak we wzorcu wyrażenia regularnego jest interpretowany jako znaki spacji literału, a grupy przechwytywania w wyrażeniu regularnym są nazywane niejawnie jak również jawnie.By default, the comparison of an input string with any literal characters in a regular expression pattern is case sensitive, white space in a regular expression pattern is interpreted as literal white-space characters, and capturing groups in a regular expression are named implicitly as well as explicitly. Można zmodyfikować te i wiele innych aspektów regularnej ekspresji przez specyfikowanie opcji regularnej ekspresji.You can modify these and several other aspects of default regular expression behavior by specifying regular expression options. Te opcje, które są wymienione w poniższej tabeli, mogą być wbudowane jako część wzorca wyrażenia regularnego lub mogą być dostarczane do System.Text.RegularExpressions.Regex konstruktora klasy lub statycznym wzorca dopasowania metodę jako System.Text.RegularExpressions.RegexOptions wartość wyliczenia.These options, which are listed in the following table, can be included inline as part of the regular expression pattern, or they can be supplied to a System.Text.RegularExpressions.Regex class constructor or static pattern matching method as a System.Text.RegularExpressions.RegexOptions enumeration value.

Członek regexoptionsRegexOptions member Wbudowany znakInline character EfektEffect
None NiedostępneNot available Użyj zachowania domyślnego.Use default behavior. Aby uzyskać więcej informacji, zobacz opcje domyślne.For more information, see Default Options.
IgnoreCase i Używa dopasowywania bez uwzględniania wielkości liter.Use case-insensitive matching. Aby uzyskać więcej informacji, zobacz dopasowanie bez uwzględniania wielkości liter.For more information, see Case-Insensitive Matching.
Multiline m Użyj trybu wielowierszowego, gdzie ^ i $ pasuje do początku i końcu każdego wiersza (zamiast początku i końca ciągu wejściowego).Use multiline mode, where ^ and $ match the beginning and end of each line (instead of the beginning and end of the input string). Aby uzyskać więcej informacji, zobacz tryb wielowierszowy.For more information, see Multiline Mode.
Singleline s Użyj trybu jednowierszowego, gdzie kropki (.) dopasowuje każdy znak (a nie każdemu znakowi, z wyjątkiem \n).Use single-line mode, where the period (.) matches every character (instead of every character except \n). Aby uzyskać więcej informacji, zobacz tryb jednowierszowy.For more information, see Singleline Mode.
ExplicitCapture n Nie przechwytuje nienazwanych grup.Do not capture unnamed groups. Jedyne prawidłowe przechwycenia są jawnie nazwane lub ponumerowane grupy z formularza (?< nazwa > Podwyrażenie).The only valid captures are explicitly named or numbered groups of the form (?<name> subexpression). Aby uzyskać więcej informacji, zobacz tylko jawne Przechwytywanie.For more information, see Explicit Captures Only.
Compiled NiedostępneNot available Kompiluj wyrażenie regularne do zestawu.Compile the regular expression to an assembly. Aby uzyskać więcej informacji, zobacz skompilowane wyrażenia regularne.For more information, see Compiled Regular Expressions.
IgnorePatternWhitespace x Wyklucz niekodowany biały znak od wzorca i włączanie komentarzy po znaku numeru (#).Exclude unescaped white space from the pattern, and enable comments after a number sign (#). Aby uzyskać więcej informacji, zobacz Ignoruj białe miejsca.For more information, see Ignore White Space.
RightToLeft NiedostępneNot available Zmień kierunek wyszukiwania.Change the search direction. Wyszukiwanie przenosi się od prawej do lewej zamiast od lewej do prawej.Search moves from right to left instead of from left to right. Aby uzyskać więcej informacji, zobacz tryb od prawej do lewej.For more information, see Right-to-Left Mode.
ECMAScript NiedostępneNot available Włącz zachowanie zgodne z ECMAScript, wyrażenie.Enable ECMAScript-compliant behavior for the expression. Aby uzyskać więcej informacji, zobacz zachowanie dopasowywania ECMAScript.For more information, see ECMAScript Matching Behavior.
CultureInvariant NiedostępneNot available Ignorowanie różnic kulturowych w języku.Ignore cultural differences in language. Aby uzyskać więcej informacji, zobacz porównanie przy użyciu niezmiennej kultury.For more information, see Comparison Using the Invariant Culture.

Określenie opcjiSpecifying the Options

Można określić opcje dla wyrażeń regularnych w jeden z trzech sposobów:You can specify options for regular expressions in one of three ways:

  • W options parametru System.Text.RegularExpressions.Regex konstruktora klasy lub statycznym (Shared w języku Visual Basic) metoda dopasowania do wzorca, takich jak Regex.Regex(String, RegexOptions) lub Regex.Match(String, String, RegexOptions).In the options parameter of a System.Text.RegularExpressions.Regex class constructor or static (Shared in Visual Basic) pattern-matching method, such as Regex.Regex(String, RegexOptions) or Regex.Match(String, String, RegexOptions). options Parametr jest bitową kombinacją OR System.Text.RegularExpressions.RegexOptions wyliczonych wartości.The options parameter is a bitwise OR combination of System.Text.RegularExpressions.RegexOptions enumerated values.

    Jeśli opcje są dostarczane do Regex wystąpienia przy użyciu options parametr konstruktora klasy, opcje są przypisane do System.Text.RegularExpressions.RegexOptions właściwości.When options are supplied to a Regex instance by using the options parameter of a class constructor, the options are assigned to the System.Text.RegularExpressions.RegexOptions property. Jednak System.Text.RegularExpressions.RegexOptions właściwość nie będzie odzwierciedlał opcje wbudowane we wzorcu wyrażenia regularnego, sam.However, the System.Text.RegularExpressions.RegexOptions property does not reflect inline options in the regular expression pattern itself.

    Poniższy przykład stanowi ilustrację.The following example provides an illustration. Używa ona options parametru Regex.Match(String, String, RegexOptions) metody, aby umożliwić dopasowanie bez uwzględniania wielkości liter i Ignorowanie wzorca odstępu przy identyfikowaniu wyrazy zaczynające się na literę "d".It uses the options parameter of the Regex.Match(String, String, RegexOptions) method to enable case-insensitive matching and to ignore pattern white space when identifying words that begin with the letter "d".

    string pattern = @"d \w+ \s";
    string input = "Dogs are decidedly good pets.";
    RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace;
    
    foreach (Match match in Regex.Matches(input, pattern, options))
       Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
    // The example displays the following output:
    //    'Dogs // found at index 0.
    //    'decidedly // found at index 9.      
    
    Dim pattern As String = "d \w+ \s"
    Dim input As String = "Dogs are decidedly good pets."
    Dim options As RegexOptions = RegexOptions.IgnoreCase Or RegexOptions.IgnorePatternWhitespace
    
    For Each match As Match In Regex.Matches(input, pattern, options)
       Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
    Next
    ' The example displays the following output:
    '    'Dogs ' found at index 0.
    '    'decidedly ' found at index 9.      
    
  • Stosując opcje wbudowane we wzorcu wyrażenia regularnego przy użyciu składni (?imnsx-imnsx).By applying inline options in a regular expression pattern with the syntax (?imnsx-imnsx). Opcja dotyczy wzorca od punktu, opcją jest zdefiniowany do końca wzorca lub punktu, w którym opcją jest niezdefiniowana przez inną opcję wbudowaną.The option applies to the pattern from the point that the option is defined to either the end of the pattern or to the point at which the option is undefined by another inline option. Należy pamiętać, że System.Text.RegularExpressions.RegexOptions właściwość Regex wystąpienia nie będzie odzwierciedlał te opcje określane w tekście.Note that the System.Text.RegularExpressions.RegexOptions property of a Regex instance does not reflect these inline options. Aby uzyskać więcej informacji, zobacz różne konstrukcje tematu.For more information, see the Miscellaneous Constructs topic.

    Poniższy przykład stanowi ilustrację.The following example provides an illustration. Używa opcji wbudowanej, aby umożliwić dopasowanie bez uwzględniania wielkości liter i Ignorowanie wzorca odstępu przy identyfikowaniu wyrazy zaczynające się na literę "d".It uses inline options to enable case-insensitive matching and to ignore pattern white space when identifying words that begin with the letter "d".

    string pattern = @"(?ix) d \w+ \s";
    string input = "Dogs are decidedly good pets.";
    
    foreach (Match match in Regex.Matches(input, pattern))
       Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
    // The example displays the following output:
    //    'Dogs // found at index 0.
    //    'decidedly // found at index 9.      
    
    Dim pattern As String = "\b(?ix) d \w+ \s"
    Dim input As String = "Dogs are decidedly good pets."
    
    For Each match As Match In Regex.Matches(input, pattern)
       Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
    Next
    ' The example displays the following output:
    '    'Dogs ' found at index 0.
    '    'decidedly ' found at index 9.      
    
  • Stosując opcje wbudowane w określonej metodzie grupowania konstruowania we wzorcu wyrażenia regularnego przy użyciu składni (?imnsx-imnsx: Podwyrażenie).By applying inline options in a particular grouping construct in a regular expression pattern with the syntax (?imnsx-imnsx:subexpression). Żaden znak przed zestawem opcji nie włącza zestawu; znak minus przed zestawem opcji wyłącza zestaw.No sign before a set of options turns the set on; a minus sign before a set of options turns the set off. (? jest stałą częścią składni konstrukcji języka, który jest wymagany, czy opcje są włączone lub wyłączone.) Opcja ma zastosowanie tylko do tej grupy.(? is a fixed part of the language construct's syntax that is required whether options are enabled or disabled.) The option applies only to that group. Aby uzyskać więcej informacji, zobacz Konstrukcje grupujące.For more information, see Grouping Constructs.

    Poniższy przykład stanowi ilustrację.The following example provides an illustration. Jej używa opcji wbudowanej w konstrukcję grupującą, aby umożliwić dopasowanie bez uwzględniania wielkości liter i Ignorowanie wzorca odstępu przy identyfikowaniu wyrazy zaczynające się na literę "d".It uses inline options in a grouping construct to enable case-insensitive matching and to ignore pattern white space when identifying words that begin with the letter "d".

    string pattern = @"\b(?ix: d \w+)\s";
    string input = "Dogs are decidedly good pets.";
    
    foreach (Match match in Regex.Matches(input, pattern))
       Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
    // The example displays the following output:
    //    'Dogs // found at index 0.
    //    'decidedly // found at index 9.      
    
    Dim pattern As String = "\b(?ix: d \w+)\s"
    Dim input As String = "Dogs are decidedly good pets."
    
    For Each match As Match In Regex.Matches(input, pattern)
       Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
    Next
    ' The example displays the following output:
    '    'Dogs ' found at index 0.
    '    'decidedly ' found at index 9.      
    

Jeśli opcje są określone w jednej linii, znak minus (-) przed opcją lub zestawem opcji powoduje wyłączenie tych opcji.If options are specified inline, a minus sign (-) before an option or set of options turns off those options. Na przykład wbudowana konstrukcja (?ix-ms) włącza RegexOptions.IgnoreCase i RegexOptions.IgnorePatternWhitespace a wyłącza opcje RegexOptions.Multiline i RegexOptions.Singleline opcje.For example, the inline construct (?ix-ms) turns on the RegexOptions.IgnoreCase and RegexOptions.IgnorePatternWhitespace options and turns off the RegexOptions.Multiline and RegexOptions.Singleline options. Wszystkie opcje wyrażeń regularnych są domyślnie wyłączone.All regular expression options are turned off by default.

Uwaga

Jeśli opcje wyrażenia regularnego określone w options parametru konflikt wywołania konstruktora lub metody za pomocą opcji określonymi wewnątrz we wzorcu wyrażenia regularnego, opcje wbudowane są używane.If the regular expression options specified in the options parameter of a constructor or method call conflict with the options specified inline in a regular expression pattern, the inline options are used.

Pięć następujących opcji wyrażenia regularnego można ustawić zarówno za pomocą parametru options i wbudowane:The following five regular expression options can be set both with the options parameter and inline:

Pięć następujących opcji wyrażenia regularnego można ustawić za pomocą options parametru, ale nie można ustawić wbudowany:The following five regular expression options can be set using the options parameter but cannot be set inline:

Określanie opcjiDetermining the Options

Można określić, które opcje są dostarczone do Regex obiektu, kiedy utworzono wystąpienie poprzez pobranie wartości tylko do odczytu Regex.Options właściwości.You can determine which options were provided to a Regex object when it was instantiated by retrieving the value of the read-only Regex.Options property. Ta właściwość jest szczególnie przydatne w przypadku określenia opcji, które są zdefiniowane dla skompilowanego wyrażenia regularnego utworzonego przez Regex.CompileToAssembly metody.This property is particularly useful for determining the options that are defined for a compiled regular expression created by the Regex.CompileToAssembly method.

Aby przetestować obecność dowolnej opcji z wyjątkiem RegexOptions.None, wykonać operację AND z wartością Regex.Options właściwości i RegexOptions wartość, w którym interesuje Cię.To test for the presence of any option except RegexOptions.None, perform an AND operation with the value of the Regex.Options property and the RegexOptions value in which you are interested. Następnie sprawdź, czy wynik jest równy RegexOptions wartość.Then test whether the result equals that RegexOptions value. Poniższy przykład sprawdza czy RegexOptions.IgnoreCase została ustawiona opcja.The following example tests whether the RegexOptions.IgnoreCase option has been set.

if ((rgx.Options & RegexOptions.IgnoreCase) == RegexOptions.IgnoreCase)
   Console.WriteLine("Case-insensitive pattern comparison.");
else
   Console.WriteLine("Case-sensitive pattern comparison.");
If (rgx.Options And RegexOptions.IgnoreCase) = RegexOptions.IgnoreCase Then
   Console.WriteLine("Case-insensitive pattern comparison.")
Else
   Console.WriteLine("Case-sensitive pattern comparison.")
End If   

Aby sprawdzić RegexOptions.None, określić, czy wartość Regex.Options właściwości jest równa RegexOptions.None, tak jak pokazano w poniższym przykładzie.To test for RegexOptions.None, determine whether the value of the Regex.Options property is equal to RegexOptions.None, as the following example illustrates.

if (rgx.Options == RegexOptions.None)
   Console.WriteLine("No options have been set.");
If rgx.Options = RegexOptions.None Then
   Console.WriteLine("No options have been set.")
End If

W poniższych sekcjach wymieniono opcje obsługiwane przez wyrażenia regularne w .NET.The following sections list the options supported by regular expression in .NET.

Opcje domyślneDefault Options

RegexOptions.None Opcja wskazuje, że nie określono żadnych opcji, a aparat wyrażeń regularnych używa swojego zachowania domyślnego.The RegexOptions.None option indicates that no options have been specified, and the regular expression engine uses its default behavior. Uwzględnione są następujące elementy:This includes the following:

  • Wzorzec jest interpretowany jako kanonicznej zamiast wyrażeń regularnych ECMAScript.The pattern is interpreted as a canonical rather than an ECMAScript regular expression.

  • Definicję wzorca wyrażenia regularnego jest dopasowywany do ciągu wejściowego od lewej do prawej.The regular expression pattern is matched in the input string from left to right.

  • Porównania uwzględniają wielkość liter.Comparisons are case-sensitive.

  • ^ i $ elementy języka pasuje do początku i końca ciągu wejściowego.The ^ and $ language elements match the beginning and end of the input string.

  • . Element języka pasuje do każdego znaku z wyjątkiem \n.The . language element matches every character except \n.

  • Dowolny odstęp we wzorcu wyrażenia regularnego jest interpretowany jako znak spacji literału.Any white space in a regular expression pattern is interpreted as a literal space character.

  • Podczas porównywania wzorca z ciągiem wejściowym, są używane konwencje bieżącej kultury.The conventions of the current culture are used when comparing the pattern to the input string.

  • Grupy przechwytywania we wzorcu wyrażenia regularnego są niejawne, jak również jawne.Capturing groups in the regular expression pattern are implicit as well as explicit.

Uwaga

RegexOptions.None Opcji nie ma odpowiednika wbudowanego.The RegexOptions.None option has no inline equivalent. Opcje wyrażeń regularnych stosowane są wbudowane, domyślne zachowanie zostanie przywrócony na podstawie opcji wg opcji przez wyłączenie konkretnej opcji.When regular expression options are applied inline, the default behavior is restored on an option-by-option basis, by turning a particular option off. Na przykład (?i) włącza porównania bez uwzględniania wielkości liter, a (?-i) przywraca domyślne porównywanie uwzględniające wielkość liter.For example, (?i) turns on case-insensitive comparison, and (?-i) restores the default case-sensitive comparison.

Ponieważ RegexOptions.None opcji reprezentuje domyślne zachowanie aparatu wyrażenia regularnego, rzadko jawnie określono w wywołaniu metody.Because the RegexOptions.None option represents the default behavior of the regular expression engine, it is rarely explicitly specified in a method call. Konstruktor lub statycznej metody dopasowania do wzorca bez options zamiast tego wywoływany jest parametr.A constructor or static pattern-matching method without an options parameter is called instead.

Powrót do początkuBack to Top

Dopasowywanie bez uwzględniania wielkości literCase-Insensitive Matching

IgnoreCase Opcji lub i opcji wbudowanej, oferuje dopasowywanie bez uwzględniania wielkości liter.The IgnoreCase option, or the i inline option, provides case-insensitive matching. Domyślnie są używane konwencje obudowy bieżącej kultury.By default, the casing conventions of the current culture are used.

W poniższym przykładzie zdefiniowano wzorzec wyrażenia regularnego \bthe\w*\b, który dopasowuje wszystkie wyrazy rozpoczynające się od ciągu "".The following example defines a regular expression pattern, \bthe\w*\b, that matches all words starting with "the". Ponieważ pierwsze wywołanie do Match metoda używa domyślnego porównania uwzględniającego wielkość liter, dane wyjściowe wskazują, że ciąg "", który rozpoczyna zdanie, nie został dopasowany.Because the first call to the Match method uses the default case-sensitive comparison, the output indicates that the string "The" that begins the sentence is not matched. Jest dopasowywany gdy Match metoda jest wywoływana z opcji zestawu IgnoreCase.It is matched when the Match method is called with options set to IgnoreCase.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bthe\w*\b";
      string input = "The man then told them about that event.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);

      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, pattern, 
                                            RegexOptions.IgnoreCase))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found then at index 8.
//       Found them at index 18.
//       
//       Found The at index 0.
//       Found then at index 8.
//       Found them at index 18.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\bthe\w*\b"
      Dim input As String = "The man then told them about that event."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
      Next
      Console.WriteLine()
      For Each match As Match In Regex.Matches(input, pattern, _
                                               RegexOptions.IgnoreCase)
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found then at index 8.
'       Found them at index 18.
'       
'       Found The at index 0.
'       Found then at index 8.
'       Found them at index 18.

Poniższy przykład modyfikuje wzorzec wyrażenia regularnego z poprzedniego przykładu, aby używał opcji wbudowanych zamiast options parametru do podania porównania bez uwzględniania wielkości liter.The following example modifies the regular expression pattern from the previous example to use inline options instead of the options parameter to provide case-insensitive comparison. Pierwszy wzorzec definiuje opcją nieuwzględniania wielkości liter w konstrukcji grupowania, która dotyczy tylko litery "t" w ciągu "".The first pattern defines the case-insensitive option in a grouping construct that applies only to the letter "t" in the string "the". Ponieważ konstrukcja opcja występuje na początku wzorca, drugi wzorzec dotyczy opcji nieuwzględniającej wielkości liter całego wyrażenia regularnego.Because the option construct occurs at the beginning of the pattern, the second pattern applies the case-insensitive option to the entire regular expression.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(?i:t)he\w*\b";
      string input = "The man then told them about that event.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);

      Console.WriteLine();
      pattern = @"(?i)\bthe\w*\b";
      foreach (Match match in Regex.Matches(input, pattern, 
                                            RegexOptions.IgnoreCase))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found The at index 0.
//       Found then at index 8.
//       Found them at index 18.
//       
//       Found The at index 0.
//       Found then at index 8.
//       Found them at index 18.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(?i:t)he\w*\b"
      Dim input As String = "The man then told them about that event."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
      Next
      Console.WriteLine()
      pattern = "(?i)\bthe\w*\b"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found The at index 0.
'       Found then at index 8.
'       Found them at index 18.
'       
'       Found The at index 0.
'       Found then at index 8.
'       Found them at index 18.

Powrót do początkuBack to Top

Tryb wielowierszowyMultiline Mode

RegexOptions.Multiline Opcji lub m opcji wbudowanej, umożliwia aparatowi wyrażeń regularnych obsługę ciągu wejściowego, który składa się z wielu wierszy.The RegexOptions.Multiline option, or the m inline option, enables the regular expression engine to handle an input string that consists of multiple lines. Zmienia interpretację ^ i $ elementów języka, aby odpowiadały na początku i na końcu wiersza, zamiast początku i końca ciągu wejściowego.It changes the interpretation of the ^ and $ language elements so that they match the beginning and end of a line, instead of the beginning and end of the input string.

Domyślnie $ pasuje do końca ciągu wejściowego.By default, $ matches only the end of the input string. Jeśli określisz RegexOptions.Multiline opcji dopasowuje znak nowego wiersza (\n) lub na końcu ciągu wejściowego.If you specify the RegexOptions.Multiline option, it matches either the newline character (\n) or the end of the input string. Nie pasuje jednak kombinacji znaków CR/LF.It does not, however, match the carriage return/line feed character combination. Aby pomyślnie je dopasować, należy użyć wyrażenia cząstkowego \r?$ zamiast po prostu $.To successfully match them, use the subexpression \r?$ instead of just $.

Poniższy przykład wyodrębnia nazwiska i wyniki kręglarzy i dodaje je do SortedList<TKey,TValue> kolekcji, która sortuje je w kolejności malejącej.The following example extracts bowlers' names and scores and adds them to a SortedList<TKey,TValue> collection that sorts them in descending order. Matches Metoda jest wywoływana dwa razy.The Matches method is called twice. W pierwszym wywołaniu metody, wyrażenie regularne jest ^(\w+)\s(\d+)$ i opcje nie są ustawione.In the first method call, the regular expression is ^(\w+)\s(\d+)$ and no options are set. Dane wyjściowe pokazują, ponieważ aparat wyrażeń regularnych nie może dopasować wzorca danych wejściowych z początkiem i końcem ciągu wejściowego, nie znaleziono żadnych dopasowań.As the output shows, because the regular expression engine cannot match the input pattern along with the beginning and end of the input string, no matches are found. W drugim wywołaniu metody, wyrażenia regularnego jest zmieniana na ^(\w+)\s(\d+)\r?$ i opcje są ustawione na RegexOptions.Multiline.In the second method call, the regular expression is changed to ^(\w+)\s(\d+)\r?$ and the options are set to RegexOptions.Multiline. Dane wyjściowe pokazują, nazwy i wyniki są pomyślnie dopasowywane, a wyniki są wyświetlane w kolejności malejącej.As the output shows, the names and scores are successfully matched, and the scores are displayed in descending order.

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      SortedList<int, string> scores = new SortedList<int, string>(new DescendingComparer<int>());
      
      string input = "Joe 164\n" + 
                     "Sam 208\n" + 
                     "Allison 211\n" + 
                     "Gwen 171\n"; 
      string pattern = @"^(\w+)\s(\d+)$";
      bool matched = false;
      
      Console.WriteLine("Without Multiline option:");
      foreach (Match match in Regex.Matches(input, pattern))
      {
         scores.Add(Int32.Parse(match.Groups[2].Value), (string) match.Groups[1].Value);
         matched = true;
      }
      if (! matched)
         Console.WriteLine("   No matches.");
      Console.WriteLine();

      // Redefine pattern to handle multiple lines.
      pattern = @"^(\w+)\s(\d+)\r*$";
      Console.WriteLine("With multiline option:");
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Multiline))
         scores.Add(Int32.Parse(match.Groups[2].Value), (string) match.Groups[1].Value);

      // List scores in descending order. 
      foreach (KeyValuePair<int, string> score in scores)
         Console.WriteLine("{0}: {1}", score.Value, score.Key);
   }
}

public class DescendingComparer<T> : IComparer<T>
{
   public int Compare(T x, T y)
   {
      return Comparer<T>.Default.Compare(x, y) * -1;       
   }
}
// The example displays the following output:
//   Without Multiline option:
//      No matches.
//   
//   With multiline option:
//   Allison: 211
//   Sam: 208
//   Gwen: 171
//   Joe: 164
Imports System.Collections.Generic
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim scores As New SortedList(Of Integer, String)(New DescendingComparer(Of Integer)())
      
      Dim input As String = "Joe 164" + vbCrLf + _
                            "Sam 208" + vbCrLf + _
                            "Allison 211" + vbCrLf + _
                            "Gwen 171" + vbCrLf
      Dim pattern As String = "^(\w+)\s(\d+)$"
      Dim matched As Boolean = False
      
      Console.WriteLine("Without Multiline option:")
      For Each match As Match In Regex.Matches(input, pattern)
         scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
         matched = True
      Next
      If Not matched Then Console.WriteLine("   No matches.")
      Console.WriteLine()

      ' Redefine pattern to handle multiple lines.
      pattern = "^(\w+)\s(\d+)\r*$"
      Console.WriteLine("With multiline option:")
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Multiline)
         scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
      Next
      ' List scores in descending order. 
      For Each score As KeyValuePair(Of Integer, String) In scores
         Console.WriteLine("{0}: {1}", score.Value, score.Key)
      Next
   End Sub
End Module

Public Class DescendingComparer(Of T) : Implements IComparer(Of T)
   Public Function Compare(x As T, y As T) As Integer _
          Implements IComparer(Of T).Compare
      Return Comparer(Of T).Default.Compare(x, y) * -1       
   End Function
End Class
' The example displays the following output:
'    Without Multiline option:
'       No matches.
'    
'    With multiline option:
'    Allison: 211
'    Sam: 208
'    Gwen: 171
'    Joe: 164

Definicję wzorca wyrażenia regularnego ^(\w+)\s(\d+)\r*$ jest zdefiniowany jak pokazano w poniższej tabeli.The regular expression pattern ^(\w+)\s(\d+)\r*$ is defined as shown in the following table.

WzorzecPattern OpisDescription
^ Rozpocznij na początku wiersza.Begin at the start of the line.
(\w+) Dopasowuje co najmniej jeden znak słowa.Match one or more word characters. Jest to pierwsza grupa przechwytywania.This is the first capturing group.
\s Dopasowuje znak odstępu.Match a white-space character.
(\d+) Dopasowanie do co najmniej jednej cyfry dziesiętnej.Match one or more decimal digits. Jest to druga grupa przechwytywania.This is the second capturing group.
\r? Odpowiada zero lub jeden znaku powrotu karetki.Match zero or one carriage return character.
$ Kończy się na końcu wiersza.End at the end of the line.

Poniższy przykład jest równoważny poprzedniemu, z tą różnicą, że używa opcji wbudowanej (?m) można ustawić opcję wiele wierszy.The following example is equivalent to the previous one, except that it uses the inline option (?m) to set the multiline option.

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      SortedList<int, string> scores = new SortedList<int, string>(new DescendingComparer<int>());
      
      string input = "Joe 164\n" +  
                     "Sam 208\n" +  
                     "Allison 211\n" +  
                     "Gwen 171\n"; 
      string pattern = @"(?m)^(\w+)\s(\d+)\r*$";

      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Multiline))
         scores.Add(Convert.ToInt32(match.Groups[2].Value), match.Groups[1].Value);

      // List scores in descending order. 
      foreach (KeyValuePair<int, string> score in scores)
         Console.WriteLine("{0}: {1}", score.Value, score.Key);
   }
}

public class DescendingComparer<T> : IComparer<T>
{
   public int Compare(T x, T y) 
   {
      return Comparer<T>.Default.Compare(x, y) * -1;       
   }
}
// The example displays the following output:
//    Allison: 211
//    Sam: 208
//    Gwen: 171
//    Joe: 164
Imports System.Collections.Generic
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim scores As New SortedList(Of Integer, String)(New DescendingComparer(Of Integer)())
      
      Dim input As String = "Joe 164" + vbCrLf + _
                            "Sam 208" + vbCrLf + _
                            "Allison 211" + vbCrLf + _
                            "Gwen 171" + vbCrLf
      Dim pattern As String = "(?m)^(\w+)\s(\d+)\r*$"

      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Multiline)
         scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
      Next
      ' List scores in descending order. 
      For Each score As KeyValuePair(Of Integer, String) In scores
         Console.WriteLine("{0}: {1}", score.Value, score.Key)
      Next
   End Sub
End Module

Public Class DescendingComparer(Of T) : Implements IComparer(Of T)
   Public Function Compare(x As T, y As T) As Integer _
          Implements IComparer(Of T).Compare
      Return Comparer(Of T).Default.Compare(x, y) * -1       
   End Function
End Class
' The example displays the following output:
'    Allison: 211
'    Sam: 208
'    Gwen: 171
'    Joe: 164

Powrót do początkuBack to Top

Tryb jednowierszowySingle-line Mode

RegexOptions.Singleline Opcji lub s opcji wbudowanej, powoduje, że aparat wyrażeń regularnych do traktowania ciąg wejściowy tak, jakby składa się z jednego wiersza.The RegexOptions.Singleline option, or the s inline option, causes the regular expression engine to treat the input string as if it consists of a single line. Robi to poprzez zmianę zachowania okresu (.) elementu języka, tak że pasuje do każdego znaku, a nie pasuje do każdego znaku z wyjątkiem znaku nowego wiersza \n lub \u000A.It does this by changing the behavior of the period (.) language element so that it matches every character, instead of matching every character except for the newline character \n or \u000A.

Poniższy przykład ilustruje sposób zachowania . zmiany elementu języka, korzystając z RegexOptions.Singleline opcji.The following example illustrates how the behavior of the . language element changes when you use the RegexOptions.Singleline option. Wyrażenie regularne ^.+ rozpoczyna się od początku ciągu i dopasowuje każdy znak.The regular expression ^.+ starts at the beginning of the string and matches every character. Domyślnie dopasowanie kończy się na końcu pierwszego wiersza; wzorzec wyrażenia regularnego pasuje do znaku powrotu karetki \r lub \u000D, ale nie jest zgodny \n.By default, the match ends at the end of the first line; the regular expression pattern matches the carriage return character, \r or \u000D, but it does not match \n. Ponieważ RegexOptions.Singleline opcji interpretuje cały ciąg wejściowy jako jeden wiersz, więc dopasowuje każdy znak w ciągu wejściowym, łącznie z \n.Because the RegexOptions.Singleline option interprets the entire input string as a single line, it matches every character in the input string, including \n.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "^.+";
      string input = "This is one line and" + Environment.NewLine + "this is the second.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(Regex.Escape(match.Value));

      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline))
         Console.WriteLine(Regex.Escape(match.Value));
   }
}
// The example displays the following output:
//       This\ is\ one\ line\ and\r
//       
//       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^.+"
      Dim input As String = "This is one line and" + vbCrLf + "this is the second."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(Regex.Escape(match.Value))
      Next
      Console.WriteLine()
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.SingleLine)
         Console.WriteLine(Regex.Escape(match.Value))
      Next
   End Sub
End Module
' The example displays the following output:
'       This\ is\ one\ line\ and\r
'       
'       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

Poniższy przykład jest równoważny poprzedniemu, z tą różnicą, że używa opcji wbudowanej (?s) do włączenia trybu jednowierszowego.The following example is equivalent to the previous one, except that it uses the inline option (?s) to enable single-line mode.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {      
      string pattern = "(?s)^.+";
      string input = "This is one line and" + Environment.NewLine + "this is the second.";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(Regex.Escape(match.Value));
   }
}
// The example displays the following output:
//       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?s)^.+"
      Dim input As String = "This is one line and" + vbCrLf + "this is the second."

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(Regex.Escape(match.Value))
      Next
   End Sub
End Module
' The example displays the following output:
'       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

Powrót do początkuBack to Top

Tylko jawne PrzechwytywanieExplicit Captures Only

Domyślnie grupy przechwytywania są definiowane przy użyciu nawiasów we wzorcu wyrażenia regularnego.By default, capturing groups are defined by the use of parentheses in the regular expression pattern. Nazwane grupy przypisano nazwę lub numer przez (?< nazwa>Podwyrażenie ) język opcji, gdzie nienazwane grupy są dostępne za pomocą indeksu.Named groups are assigned a name or number by the (?<name>subexpression) language option, whereas unnamed groups are accessible by index. W GroupCollection obiektu grupy bez nazwy poprzedzają nazwane grupy.In the GroupCollection object, unnamed groups precede named groups.

Konstrukcje grupowania są często używane tylko po to, aby zastosować Kwantyfikatory do wielu elementów języka, a przechwycone podciągi są nie interesujące.Grouping constructs are often used only to apply quantifiers to multiple language elements, and the captured substrings are of no interest. Na przykład jeśli następujące wyrażenie regularne:For example, if the following regular expression:

\b\(?((\w+),?\s?)+[\.!?]\)?

jest przeznaczony tylko do wyodrębnienia zdań, które kończą się kropką, wykrzyknikiem lub znakiem zapytania z dokumentu, tylko wynikowy zdanie (które jest reprezentowane przez Match obiekt) ma znaczenie.is intended only to extract sentences that end with a period, exclamation point, or question mark from a document, only the resulting sentence (which is represented by the Match object) is of interest. Poszczególne wyrazy w kolekcji nie są.The individual words in the collection are not.

Grupy przechwytywania, które nie są następnie używane mogą być kosztowne, ponieważ aparat wyrażeń regularnych musi wypełniać GroupCollection i CaptureCollection kolekcji obiektów.Capturing groups that are not subsequently used can be expensive, because the regular expression engine must populate both the GroupCollection and CaptureCollection collection objects. Alternatywnie, można użyć RegexOptions.ExplicitCapture opcji lub n opcji wbudowanej, aby określić jawnie nazwane lub ponumerowane grupy, które są oznaczone przez jedyne prawidłowe przechwycenia (?< nazwa > Podwyrażenie ) konstruowania.As an alternative, you can use either the RegexOptions.ExplicitCapture option or the n inline option to specify that the only valid captures are explicitly named or numbered groups that are designated by the (?<name> subexpression) construct.

Poniższy przykład wyświetla informacje o dopasowań zwracana przez \b\(?((\w+),?\s?)+[\.!?]\)? wzorca wyrażenia regularnego, gdy Match metoda jest wywoływana z lub bez RegexOptions.ExplicitCapture opcji.The following example displays information about the matches returned by the \b\(?((\w+),?\s?)+[\.!?]\)? regular expression pattern when the Match method is called with and without the RegexOptions.ExplicitCapture option. Jak wynika z pierwszej metody wywołania, aparat wyrażeń regularnych GroupCollection i CaptureCollection kolekcji obiektów z informacjami o przechwyconych podciągach.As the output from the first method call shows, the regular expression engine fully populates the GroupCollection and CaptureCollection collection objects with information about captured substrings. Ponieważ druga metoda jest wywoływana z options równa RegexOptions.ExplicitCapture, nie przechwytuje informacji na temat grup.Because the second method is called with options set to RegexOptions.ExplicitCapture, it does not capture information on groups.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"\b\(?((?>\w+),?\s?)+[\.!?]\)?";
      Console.WriteLine("With implicit captures:");
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine("The match: {0}", match.Value);
         int groupCtr = 0;
         foreach (Group group in match.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
            groupCtr++;
            int captureCtr = 0;
            foreach (Capture capture in group.Captures)
            {
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
               captureCtr++;
            }
         }
      }
      Console.WriteLine();
      Console.WriteLine("With explicit captures only:");
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.ExplicitCapture))
      {
         Console.WriteLine("The match: {0}", match.Value);
         int groupCtr = 0;
         foreach (Group group in match.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
            groupCtr++;
            int captureCtr = 0;
            foreach (Capture capture in group.Captures)
            {
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
               captureCtr++;
            }
         }
      }
   }
}
// The example displays the following output:
//    With implicit captures:
//    The match: This is the first sentence.
//       Group 0: This is the first sentence.
//          Capture 0: This is the first sentence.
//       Group 1: sentence
//          Capture 0: This
//          Capture 1: is
//          Capture 2: the
//          Capture 3: first
//          Capture 4: sentence
//       Group 2: sentence
//          Capture 0: This
//          Capture 1: is
//          Capture 2: the
//          Capture 3: first
//          Capture 4: sentence
//    The match: Is it the beginning of a literary masterpiece?
//       Group 0: Is it the beginning of a literary masterpiece?
//          Capture 0: Is it the beginning of a literary masterpiece?
//       Group 1: masterpiece
//          Capture 0: Is
//          Capture 1: it
//          Capture 2: the
//          Capture 3: beginning
//          Capture 4: of
//          Capture 5: a
//          Capture 6: literary
//          Capture 7: masterpiece
//       Group 2: masterpiece
//          Capture 0: Is
//          Capture 1: it
//          Capture 2: the
//          Capture 3: beginning
//          Capture 4: of
//          Capture 5: a
//          Capture 6: literary
//          Capture 7: masterpiece
//    The match: I think not.
//       Group 0: I think not.
//          Capture 0: I think not.
//       Group 1: not
//          Capture 0: I
//          Capture 1: think
//          Capture 2: not
//       Group 2: not
//          Capture 0: I
//          Capture 1: think
//          Capture 2: not
//    The match: Instead, it is a nonsensical paragraph.
//       Group 0: Instead, it is a nonsensical paragraph.
//          Capture 0: Instead, it is a nonsensical paragraph.
//       Group 1: paragraph
//          Capture 0: Instead,
//          Capture 1: it
//          Capture 2: is
//          Capture 3: a
//          Capture 4: nonsensical
//          Capture 5: paragraph
//       Group 2: paragraph
//          Capture 0: Instead
//          Capture 1: it
//          Capture 2: is
//          Capture 3: a
//          Capture 4: nonsensical
//          Capture 5: paragraph
//    
//    With explicit captures only:
//    The match: This is the first sentence.
//       Group 0: This is the first sentence.
//          Capture 0: This is the first sentence.
//    The match: Is it the beginning of a literary masterpiece?
//       Group 0: Is it the beginning of a literary masterpiece?
//          Capture 0: Is it the beginning of a literary masterpiece?
//    The match: I think not.
//       Group 0: I think not.
//          Capture 0: I think not.
//    The match: Instead, it is a nonsensical paragraph.
//       Group 0: Instead, it is a nonsensical paragraph.
//          Capture 0: Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "\b\(?((?>\w+),?\s?)+[\.!?]\)?"
      Console.WriteLine("With implicit captures:")
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("The match: {0}", match.Value)
         Dim groupCtr As Integer = 0
         For Each group As Group In match.Groups
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
            groupCtr += 1
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
               captureCtr += 1
            Next
         Next
      Next
      Console.WriteLine()
      Console.WriteLine("With explicit captures only:")
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.ExplicitCapture)
         Console.WriteLine("The match: {0}", match.Value)
         Dim groupCtr As Integer = 0
         For Each group As Group In match.Groups
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
            groupCtr += 1
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
               captureCtr += 1
            Next
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'    With implicit captures:
'    The match: This is the first sentence.
'       Group 0: This is the first sentence.
'          Capture 0: This is the first sentence.
'       Group 1: sentence
'          Capture 0: This
'          Capture 1: is
'          Capture 2: the
'          Capture 3: first
'          Capture 4: sentence
'       Group 2: sentence
'          Capture 0: This
'          Capture 1: is
'          Capture 2: the
'          Capture 3: first
'          Capture 4: sentence
'    The match: Is it the beginning of a literary masterpiece?
'       Group 0: Is it the beginning of a literary masterpiece?
'          Capture 0: Is it the beginning of a literary masterpiece?
'       Group 1: masterpiece
'          Capture 0: Is
'          Capture 1: it
'          Capture 2: the
'          Capture 3: beginning
'          Capture 4: of
'          Capture 5: a
'          Capture 6: literary
'          Capture 7: masterpiece
'       Group 2: masterpiece
'          Capture 0: Is
'          Capture 1: it
'          Capture 2: the
'          Capture 3: beginning
'          Capture 4: of
'          Capture 5: a
'          Capture 6: literary
'          Capture 7: masterpiece
'    The match: I think not.
'       Group 0: I think not.
'          Capture 0: I think not.
'       Group 1: not
'          Capture 0: I
'          Capture 1: think
'          Capture 2: not
'       Group 2: not
'          Capture 0: I
'          Capture 1: think
'          Capture 2: not
'    The match: Instead, it is a nonsensical paragraph.
'       Group 0: Instead, it is a nonsensical paragraph.
'          Capture 0: Instead, it is a nonsensical paragraph.
'       Group 1: paragraph
'          Capture 0: Instead,
'          Capture 1: it
'          Capture 2: is
'          Capture 3: a
'          Capture 4: nonsensical
'          Capture 5: paragraph
'       Group 2: paragraph
'          Capture 0: Instead
'          Capture 1: it
'          Capture 2: is
'          Capture 3: a
'          Capture 4: nonsensical
'          Capture 5: paragraph
'    
'    With explicit captures only:
'    The match: This is the first sentence.
'       Group 0: This is the first sentence.
'          Capture 0: This is the first sentence.
'    The match: Is it the beginning of a literary masterpiece?
'       Group 0: Is it the beginning of a literary masterpiece?
'          Capture 0: Is it the beginning of a literary masterpiece?
'    The match: I think not.
'       Group 0: I think not.
'          Capture 0: I think not.
'    The match: Instead, it is a nonsensical paragraph.
'       Group 0: Instead, it is a nonsensical paragraph.
'          Capture 0: Instead, it is a nonsensical paragraph.

Definicję wzorca wyrażenia regularnego\b\(?((?>\w+),?\s?)+[\.!?]\)? jest zdefiniowany jak pokazano w poniższej tabeli.The regular expression pattern\b\(?((?>\w+),?\s?)+[\.!?]\)? is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpocznij na granicy wyrazu.Begin at a word boundary.
\(? Dopasowuje zero lub jeden wystąpień nawias otwierający ("(").Match zero or one occurrences of the opening parenthesis ("(").
(?>\w+),? Dopasowuje znak słowa, następuje zero lub jeden przecinek.Match one or more word characters, followed by zero or one commas. Nie wykonuj nawrotu podczas dopasowywania znaków słowa.Do not backtrack when matching word characters.
\s? Dopasowanie do zera lub jednego znaku odstępu.Match zero or one white-space characters.
((\w+),?\s?)+ Dopasowuje kombinacji jednego lub więcej znaków wyrazu, zero lub jeden przecinek i zero lub jeden znak odstępu jeden lub więcej razy.Match the combination of one or more word characters, zero or one commas, and zero or one white-space characters one or more times.
[\.!?]\)? Pasuje do żadnego trzy symbole znaków interpunkcyjnych, w którym następuje zero lub jeden zamykający nawias (")").Match any of the three punctuation symbols, followed by zero or one closing parentheses (")").

Można również użyć (?n) wbudowanego elementu do blokowania automatycznego przechwytywania.You can also use the (?n) inline element to suppress automatic captures. Poniższy przykład modyfikuje poprzedni wzorzec wyrażenia regularnego, aby użyć (?n) wbudowanego elementu zamiast RegexOptions.ExplicitCapture opcji.The following example modifies the previous regular expression pattern to use the (?n) inline element instead of the RegexOptions.ExplicitCapture option.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"(?n)\b\(?((?>\w+),?\s?)+[\.!?]\)?";

      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine("The match: {0}", match.Value);
         int groupCtr = 0;
         foreach (Group group in match.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
            groupCtr++;
            int captureCtr = 0;
            foreach (Capture capture in group.Captures)
            {
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
               captureCtr++;
            }
         }
      }
   }
}
// The example displays the following output:
//       The match: This is the first sentence.
//          Group 0: This is the first sentence.
//             Capture 0: This is the first sentence.
//       The match: Is it the beginning of a literary masterpiece?
//          Group 0: Is it the beginning of a literary masterpiece?
//             Capture 0: Is it the beginning of a literary masterpiece?
//       The match: I think not.
//          Group 0: I think not.
//             Capture 0: I think not.
//       The match: Instead, it is a nonsensical paragraph.
//          Group 0: Instead, it is a nonsensical paragraph.
//             Capture 0: Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "(?n)\b\(?((?>\w+),?\s?)+[\.!?]\)?"

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("The match: {0}", match.Value)
         Dim groupCtr As Integer = 0
         For Each group As Group In match.Groups
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
            groupCtr += 1
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
               captureCtr += 1
            Next
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       The match: This is the first sentence.
'          Group 0: This is the first sentence.
'             Capture 0: This is the first sentence.
'       The match: Is it the beginning of a literary masterpiece?
'          Group 0: Is it the beginning of a literary masterpiece?
'             Capture 0: Is it the beginning of a literary masterpiece?
'       The match: I think not.
'          Group 0: I think not.
'             Capture 0: I think not.
'       The match: Instead, it is a nonsensical paragraph.
'          Group 0: Instead, it is a nonsensical paragraph.
'             Capture 0: Instead, it is a nonsensical paragraph.

Na koniec można użyć wbudowanego elementu grupy (?n:) do blokowania automatycznego przechwytywania na podstawie przez grupy.Finally, you can use the inline group element (?n:) to suppress automatic captures on a group-by-group basis. Poniższy przykład modyfikuje poprzedni wzorzec do pomijania nienazwane przechwytywania w grupy zewnętrznej ((?>\w+),?\s?).The following example modifies the previous pattern to suppress unnamed captures in the outer group, ((?>\w+),?\s?). Należy zauważyć, że to pomija nienazwane przechwytywania w grupy wewnętrznej.Note that this suppresses unnamed captures in the inner group as well.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"\b\(?(?n:(?>\w+),?\s?)+[\.!?]\)?";

      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine("The match: {0}", match.Value);
         int groupCtr = 0;
         foreach (Group group in match.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
            groupCtr++;
            int captureCtr = 0;
            foreach (Capture capture in group.Captures)
            {
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
               captureCtr++;
            }
         }
      }
   }
}
// The example displays the following output:
//       The match: This is the first sentence.
//          Group 0: This is the first sentence.
//             Capture 0: This is the first sentence.
//       The match: Is it the beginning of a literary masterpiece?
//          Group 0: Is it the beginning of a literary masterpiece?
//             Capture 0: Is it the beginning of a literary masterpiece?
//       The match: I think not.
//          Group 0: I think not.
//             Capture 0: I think not.
//       The match: Instead, it is a nonsensical paragraph.
//          Group 0: Instead, it is a nonsensical paragraph.
//             Capture 0: Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "\b\(?(?n:(?>\w+),?\s?)+[\.!?]\)?"

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("The match: {0}", match.Value)
         Dim groupCtr As Integer = 0
         For Each group As Group In match.Groups
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
            groupCtr += 1
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
               captureCtr += 1
            Next
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       The match: This is the first sentence.
'          Group 0: This is the first sentence.
'             Capture 0: This is the first sentence.
'       The match: Is it the beginning of a literary masterpiece?
'          Group 0: Is it the beginning of a literary masterpiece?
'             Capture 0: Is it the beginning of a literary masterpiece?
'       The match: I think not.
'          Group 0: I think not.
'             Capture 0: I think not.
'       The match: Instead, it is a nonsensical paragraph.
'          Group 0: Instead, it is a nonsensical paragraph.
'             Capture 0: Instead, it is a nonsensical paragraph.

Powrót do początkuBack to Top

Skompilowane wyrażenia regularneCompiled Regular Expressions

Domyślnie są interpretowane wyrażenia regularne w .NET.By default, regular expressions in .NET are interpreted. Gdy Regex obiektu jest skonkretyzowany lub statyczna Regex metoda jest wywoływana, wzorzec wyrażenia regularnego jest analizowany na zbiór niestandardowych rozkazów i interpretujący używa tych rozkazów do uruchomienia wyrażenia regularnego.When a Regex object is instantiated or a static Regex method is called, the regular expression pattern is parsed into a set of custom opcodes, and an interpreter uses these opcodes to run the regular expression. Obejmuje to to z kompromisem: Koszt inicjowania aparatu wyrażeń regularnych jest zminimalizowany kosztem wydajności w czasie wykonywania.This involves a tradeoff: The cost of initializing the regular expression engine is minimized at the expense of run-time performance.

Można użyć skompilowanych zamiast interpretowanych wyrażeń regularnych, za pomocą RegexOptions.Compiled opcji.You can use compiled instead of interpreted regular expressions by using the RegexOptions.Compiled option. W tym przypadku gdy wzorzec zostanie przekazany do aparatu wyrażeń regularnych, jest analizowany na zbiór rozkazów i następnie konwertowany na język Microsoft intermediate language (MSIL), które mogą być przekazywane bezpośrednio do środowiska uruchomieniowego języka wspólnego.In this case, when a pattern is passed to the regular expression engine, it is parsed into a set of opcodes and then converted to Microsoft intermediate language (MSIL), which can be passed directly to the common language runtime. Skompilowane wyrażenia regularne maksymalizują wydajność uruchomieniową kosztem czasu inicjowania.Compiled regular expressions maximize run-time performance at the expense of initialization time.

Uwaga

Wyrażenie regularne może być kompilowane tylko poprzez dostarczenie RegexOptions.Compiled wartość options parametru Regex konstruktora klasy lub statycznej metody dopasowania do wzorca.A regular expression can be compiled only by supplying the RegexOptions.Compiled value to the options parameter of a Regex class constructor or a static pattern-matching method. Nie jest dostępna jako opcja wbudowana.It is not available as an inline option.

Można użyć skompilowanych wyrażeń regularnych w wywołaniach statycznych i przypadkowych wyrażeń regularnych.You can use compiled regular expressions in calls to both static and instance regular expressions. W statycznych wyrażeniach regularnych RegexOptions.Compiled opcji jest przekazywany do options parametru metody dopasowania do wzorca wyrażenia regularnego.In static regular expressions, the RegexOptions.Compiled option is passed to the options parameter of the regular expression pattern-matching method. W wyrażeniach regularnych wystąpień jest przekazywana do options parametru Regex konstruktora klasy.In instance regular expressions, it is passed to the options parameter of the Regex class constructor. W obu przypadkach go powoduje zwiększoną wydajność.In both cases, it results in enhanced performance.

Jednakże ta poprawa wydajności występuje tylko w następujących warunkach:However, this improvement in performance occurs only under the following conditions:

  • A Regex obiekt, który reprezentuje określonego wyrażenia regularnego jest używana w wielu wywołaniach metod dopasowania do wzorca wyrażenia regularnego.A Regex object that represents a particular regular expression is used in multiple calls to regular expression pattern-matching methods.

  • Regex Obiektu nie może wykraczać poza zakres, dzięki czemu mogą być ponownie używane.The Regex object is not allowed to go out of scope, so it can be reused.

  • Statyczne wyrażenie regularne jest używane w wielu wywołaniach metod dopasowania do wzorca wyrażenia regularnego.A static regular expression is used in multiple calls to regular expression pattern-matching methods. (Wzrost wydajności jest możliwy, ponieważ wyrażenia regularne użyte w wywołaniach metody statycznej są buforowane przez silnik wyrażeń regularnych).(The performance improvement is possible because regular expressions used in static method calls are cached by the regular expression engine.)

Uwaga

RegexOptions.Compiled Opcja nie jest powiązana z Regex.CompileToAssembly metody, która tworzy zestaw specjalny zawierający wstępnie skompilowane wyrażenia regularne.The RegexOptions.Compiled option is unrelated to the Regex.CompileToAssembly method, which creates a special-purpose assembly that contains predefined compiled regular expressions.

Powrót do początkuBack to Top

Ignoruj białe miejscaIgnore White Space

Domyślnie biały znak we wzorcu wyrażenia regularnego ma znaczenie; Wymusza aparat wyrażeń regularnych, aby dopasować znak odstępu, w ciągu wejściowym.By default, white space in a regular expression pattern is significant; it forces the regular expression engine to match a white-space character in the input string. W związku z tym, wyrażenie regularne "\b\w+\s"i"\b\w+ " są mniej więcej odpowiednikami wyrażeń regularnych.Because of this, the regular expression "\b\w+\s" and "\b\w+ " are roughly equivalent regular expressions. Ponadto po napotkaniu we wzorcu wyrażenia regularnego znak numeru (#) jest interpretowany jako znak literałowy, do dopasowania.In addition, when the number sign (#) is encountered in a regular expression pattern, it is interpreted as a literal character to be matched.

RegexOptions.IgnorePatternWhitespace Opcji lub x opcji wbudowanej, zmienia to zachowanie domyślne w następujący sposób:The RegexOptions.IgnorePatternWhitespace option, or the x inline option, changes this default behavior as follows:

  • Niekodowany biały znak we wzorcu wyrażenia regularnego jest ignorowany.Unescaped white space in the regular expression pattern is ignored. Jako część wzorca wyrażenia regularnego, musi być zmienione znaczenie znaków spacji (na przykład, jako \s lub "\ ").To be part of a regular expression pattern, white-space characters must be escaped (for example, as \s or "\ ").

  • Znak numeru (#) jest interpretowany jako początek komentarza, a nie jako znak literałowy.The number sign (#) is interpreted as the beginning of a comment, rather than as a literal character. Cały tekst we wzorcu wyrażenia regularnego od znaku # do końca ciągu jest interpretowany jako komentarz.All text in the regular expression pattern from the # character to the end of the string is interpreted as a comment.

Jednak w następujących przypadkach białe znaki w wyrażeniu regularnym nie są ignorowane, nawet w przypadku używania RegexOptions.IgnorePatternWhitespace opcji:However, in the following cases, white-space characters in a regular expression aren't ignored, even if you use the RegexOptions.IgnorePatternWhitespace option:

  • Biały znak w klasie znaku zawsze jest interpretowany dosłownie.White space within a character class is always interpreted literally. Na przykład wzorzec wyrażenia regularnego [ .,;:] pasuje do dowolnego pojedynczy znak odstępu, okres, przecinek, średnik lub średnikami.For example, the regular expression pattern [ .,;:] matches any single white-space character, period, comma, semicolon, or colon.

  • Biały znak nie jest dozwolona w nawiasach kwadratowych kwantyfikator, takich jak { n}, { n,}, i { n , m}.White space isn't allowed within a bracketed quantifier, such as {n}, {n,}, and {n,m}. Na przykład wzorzec wyrażenia regularnego \d{1, 3} nie powiedzie się dopasować istnienie sekwencji cyfr od jednej do trzech cyfr, ponieważ zawiera znak odstępu.For example, the regular expression pattern \d{1, 3} fails to match any sequences of digits from one to three digits because it contains a white-space character.

  • Biały znak nie jest dozwolone w obrębie sekwencji znaków, która wprowadza element języka.White space isn't allowed within a character sequence that introduces a language element. Na przykład:For example:

    • Element języka (?: Podwyrażenie ) reprezentuje grupę nieprzechwytującą i (?: część elementu nie można osadzić miejsca do magazynowania.The language element (?:subexpression) represents a noncapturing group, and the (?: portion of the element can't have embedded spaces. Wzorzec (? : Podwyrażenie ) zgłasza ArgumentException w czasie wykonywania, ponieważ aparat wyrażeń regularnych nie można przeanalizować wzorzec i wzorzec ( ?: Podwyrażenie ) nie powiedzie się dopasować Podwyrażenie.The pattern (? :subexpression) throws an ArgumentException at run time because the regular expression engine can't parse the pattern, and the pattern ( ?:subexpression) fails to match subexpression.

    • Element języka \p{ nazwa}, która reprezentuje kategorię Unicode, lub o nazwie bloku, nie może zawierać spacji osadzonych w \p{ część elementu.The language element \p{name}, which represents a Unicode category or named block, can't include embedded spaces in the \p{ portion of the element. Jeśli dołączysz do odstępu, element zgłasza ArgumentException w czasie wykonywania.If you do include a white space, the element throws an ArgumentException at run time.

Włączenie tej opcji pomaga uprościć wyrażenia regularne, które są często trudne do analizowania i zrozumienia.Enabling this option helps simplify regular expressions that are often difficult to parse and to understand. Zwiększa czytelność i umożliwia dokumentowanie wyrażenia regularnego.It improves readability, and makes it possible to document a regular expression.

Poniższy przykład definiuje następujący wzorzec wyrażenia regularnego:The following example defines the following regular expression pattern:

\b \(? ( (?>\w+) ,?\s? )+ [\.!?] \)? # Matches an entire sentence.

Wzorzec ten jest podobny do wzorca określonego w tylko jawne Przechwytywanie sekcji, z tą różnicą, że używa RegexOptions.IgnorePatternWhitespace możliwość Ignorowanie wzorca odstępu.This pattern is similar to the pattern defined in the Explicit Captures Only section, except that it uses the RegexOptions.IgnorePatternWhitespace option to ignore pattern white space.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"\b\(?((?>\w+),?\s?)+[\.!?]\)?";

      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       This is the first sentence.
//       Is it the beginning of a literary masterpiece?
//       I think not.
//       Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "\b \(? ( (?>\w+) ,?\s? )+  [\.!?] \)? # Matches an entire sentence."
      
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       This is the first sentence.
'       Is it the beginning of a literary masterpiece?
'       I think not.
'       Instead, it is a nonsensical paragraph.

Poniższy przykład używa opcji wbudowanej (?x) Ignorowanie wzorca odstępu.The following example uses the inline option (?x) to ignore pattern white space.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"(?x)\b \(? ( (?>\w+) ,?\s? )+  [\.!?] \)? # Matches an entire sentence.";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       This is the first sentence.
//       Is it the beginning of a literary masterpiece?
//       I think not.
//       Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "(?x)\b \(? ( (?>\w+) ,?\s? )+  [\.!?] \)? # Matches an entire sentence."
      
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       This is the first sentence.
'       Is it the beginning of a literary masterpiece?
'       I think not.
'       Instead, it is a nonsensical paragraph.

Powrót do początkuBack to Top

Tryb od prawej do lewejRight-to-Left Mode

Domyślnie aparat wyrażenia regularnego przeszukuje od lewej do prawej.By default, the regular expression engine searches from left to right. Można odwrócić kierunek poszukiwania, używając RegexOptions.RightToLeft opcji.You can reverse the search direction by using the RegexOptions.RightToLeft option. Wyszukiwanie rozpoczyna się automatycznie od ostatniej pozycji znaku w ciągu.The search automatically begins at the last character position of the string. Dla metod dopasowania do wzorca, które obejmują początkowy pozycji parametrów, takich jak Regex.Match(String, Int32), pozycja początkowa jest indeksem pozycji znaku po prawej stronie, w którym ma się rozpocząć wyszukiwanie.For pattern-matching methods that include a starting position parameter, such as Regex.Match(String, Int32), the starting position is the index of the rightmost character position at which the search is to begin.

Uwaga

Tryb wzorca od prawej do lewej jest dostępny tylko poprzez dostarczenie RegexOptions.RightToLeft wartość options parametru Regex konstruktora klasy lub statycznej metody dopasowania do wzorca.Right-to-left pattern mode is available only by supplying the RegexOptions.RightToLeft value to the options parameter of a Regex class constructor or static pattern-matching method. Nie jest dostępna jako opcja wbudowana.It is not available as an inline option.

RegexOptions.RightToLeft Opcji zmienia jedynie kierunek wyszukiwania; nie interpretuje wzorca wyrażenia regularnego od prawej do lewej.The RegexOptions.RightToLeft option changes the search direction only; it does not interpret the regular expression pattern from right to left. Na przykład, wyrażenie regularne \bb\w+\s dopasowuje słowa, które zaczynają się od litery "b" i których następuje znak odstępu.For example, the regular expression \bb\w+\s matches words that begin with the letter "b" and are followed by a white-space character. W poniższym przykładzie ciąg wejściowy składa się z trzech słów, które zawierają jeden lub więcej znaków "b".In the following example, the input string consists of three words that include one or more "b" characters. Pierwszy wyraz rozpoczyna się znakiem "b", drugi kończy się znakiem "b", a trzeci zawiera dwa znaki "b" w środku.The first word begins with "b", the second ends with "b", and the third includes two "b" characters in the middle of the word. Dane wyjściowe z przykładu pokazują, tylko pierwszy wyraz pasuje do wzorca wyrażenia regularnego.As the output from the example shows, only the first word matches the regular expression pattern.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bb\w+\s";
      string input = "builder rob rabble";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.RightToLeft))
         Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);     
   }
}
// The example displays the following output:
//       'builder ' found at position 0.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\bb\w+\s"
      Dim input As String = "builder rob rabble"
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.RightToLeft)
         Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)     
      Next
   End Sub
End Module
' The example displays the following output:
'       'builder ' found at position 0.

Należy również zauważyć, że asercja wyprzedzająca o ( (?= Podwyrażenie ) element języka) i asercja z patrzeniem ( (?<= Podwyrażenie )element języka) nie zmieniają kierunku.Also note that the lookahead assertion (the (?=subexpression) language element) and the lookbehind assertion (the (?<=subexpression) language element) do not change direction. Asercje wyprzedzające "patrzą" po prawej stronie; asercje wsteczne się po lewej stronie.The lookahead assertions look to the right; the lookbehind assertions look to the left. Na przykład, wyrażenie regularne (?<=\d{1,2}\s)\w+,?\s\d{4} używa asercja wsteczna o do testowania dla daty, który poprzedza nazwę miesiąca.For example, the regular expression (?<=\d{1,2}\s)\w+,?\s\d{4} uses the lookbehind assertion to test for a date that precedes a month name. Następnie wyrażenie regularne dopasowuje miesiąc i rok.The regular expression then matches the month and the year. Informacje na temat potwierdzeń lookahead i można zobaczyć Grouping Constructs.For information on lookahead and lookbehind assertions, see Grouping Constructs.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "1 May 1917", "June 16, 2003" };
      string pattern = @"(?<=\d{1,2}\s)\w+,?\s\d{4}";
      
      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern, RegexOptions.RightToLeft);
         if (match.Success)
            Console.WriteLine("The date occurs in {0}.", match.Value);
         else
            Console.WriteLine("{0} does not match.", input);
      }
   }
}
// The example displays the following output:
//       The date occurs in May 1917.
//       June 16, 2003 does not match.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "1 May 1917", "June 16, 2003" }
      Dim pattern As String = "(?<=\d{1,2}\s)\w+,?\s\d{4}"
      
      For Each input As String In inputs
         Dim match As Match = Regex.Match(input, pattern, RegexOptions.RightToLeft)
         If match.Success Then
            Console.WriteLine("The date occurs in {0}.", match.Value)
         Else
            Console.WriteLine("{0} does not match.", input)
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       The date occurs in May 1917.
'       June 16, 2003 does not match.

Definicję wzorca wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.The regular expression pattern is defined as shown in the following table.

WzorzecPattern OpisDescription
(?<=\d{1,2}\s) Początek dopasowania musi być poprzedzony przez jedną lub dwiema cyframi dziesiętnymi, następuje spacja.The beginning of the match must be preceded by one or two decimal digits followed by a space.
\w+ Dopasowuje co najmniej jeden znak słowa.Match one or more word characters.
,? Dopasowuje zero lub jeden znak przecinka.Match zero or one comma characters.
\s Dopasowuje znak odstępu.Match a white-space character.
\d{4} Odpowiada czterem cyfrom po przecinku.Match four decimal digits.

Powrót do początkuBack to Top

Zachowanie dopasowywania ECMAScriptECMAScript Matching Behavior

Domyślnie aparat wyrażenia regularnego używa zachowania kanonicznego podczas dopasowywania wzorca wyrażenia regularnego do tekstu wejściowego.By default, the regular expression engine uses canonical behavior when matching a regular expression pattern to input text. Jednak można nakazać aparat wyrażeń regularnych, aby użyć ECMAScript pasujące do zachowania, określając RegexOptions.ECMAScript opcji.However, you can instruct the regular expression engine to use ECMAScript matching behavior by specifying the RegexOptions.ECMAScript option.

Uwaga

Zachowanie zgodne z ECMAScript jest dostępne tylko poprzez dostarczenie RegexOptions.ECMAScript wartość options parametru Regex konstruktora klasy lub statycznej metody dopasowania do wzorca.ECMAScript-compliant behavior is available only by supplying the RegexOptions.ECMAScript value to the options parameter of a Regex class constructor or static pattern-matching method. Nie jest dostępna jako opcja wbudowana.It is not available as an inline option.

RegexOptions.ECMAScript Opcja może być łączone tylko z RegexOptions.IgnoreCase i RegexOptions.Multiline opcje.The RegexOptions.ECMAScript option can be combined only with the RegexOptions.IgnoreCase and RegexOptions.Multiline options. Użyj innej opcji w wyrażeniu regularnym powoduje ArgumentOutOfRangeException.The use of any other option in a regular expression results in an ArgumentOutOfRangeException.

Zachowanie ECMAScript i kanonicznych wyrażeń regularnych różni się w trzech obszarach: składni klasy odwołujących się do grupy przechwytywania i ósemkowych w porównaniu z dopasowywania wstecznego interpretacji znaków.The behavior of ECMAScript and canonical regular expressions differs in three areas: character class syntax, self-referencing capturing groups, and octal versus backreference interpretation.

  • Składnia klasy znaku.Character class syntax. Ponieważ kanoniczne wyrażenia regularne obsługują Unicode, natomiast ECMAScript nie, klasy znaku w ECMAScript mają bardziej ograniczoną składnię, a niektóre elementy języka klasy znaku mają inne znaczenie.Because canonical regular expressions support Unicode whereas ECMAScript does not, character classes in ECMAScript have a more limited syntax, and some character class language elements have a different meaning. Na przykład ECMAScript nie obsługuje elementów języka, takich jak elementy kategorii lub blok Unicode \p i \P.For example, ECMAScript does not support language elements such as the Unicode category or block elements \p and \P. Podobnie \w element, który pasuje do znaku słowa, jest odpowiednikiem [a-zA-Z_0-9] klasy znaków, korzystając z ECMAScript i [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}] korzystając z zachowania kanonicznego.Similarly, the \w element, which matches a word character, is equivalent to the [a-zA-Z_0-9] character class when using ECMAScript and [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}] when using canonical behavior. Aby uzyskać więcej informacji, zobacz klas znaków.For more information, see Character Classes.

    Poniższy przykład ilustruje różnicę między kanonicznym i ECMAScript dopasowywania do wzorca.The following example illustrates the difference between canonical and ECMAScript pattern matching. Definiuje wyrażenie regularne \b(\w+\s*)+, które odpowiada wyrazom następują znaki odstępu.It defines a regular expression, \b(\w+\s*)+, that matches words followed by white-space characters. Dane wejściowe składa się z dwóch ciągów, jeden używa zestawu znaków łacińskich, a druga używa zestawu znaków cyrylicy.The input consists of two strings, one that uses the Latin character set and the other that uses the Cyrillic character set. Tak jak pokazano w danych wyjściowych, wywołanie Regex.IsMatch(String, String, RegexOptions) metody, która używa dopasowywania ECMAScript nie powiedzie się do dopasowania słów w cyrylicy, podczas gdy wywołanie metody używające dopasowania kanonicznego.As the output shows, the call to the Regex.IsMatch(String, String, RegexOptions) method that uses ECMAScript matching fails to match the Cyrillic words, whereas the method call that uses canonical matching does match these words.

    using System;
    using System.Text.RegularExpressions;
    
    public class Example
    {
       public static void Main()
       {
          string[] values = { "целый мир", "the whole world" };
          string pattern = @"\b(\w+\s*)+";
          foreach (var value in values)
          {
             Console.Write("Canonical matching: ");
             if (Regex.IsMatch(value, pattern))
                Console.WriteLine("'{0}' matches the pattern.", value);
             else
                Console.WriteLine("{0} does not match the pattern.", value);
             
             Console.Write("ECMAScript matching: ");
             if (Regex.IsMatch(value, pattern, RegexOptions.ECMAScript))
                Console.WriteLine("'{0}' matches the pattern.", value);
             else
                Console.WriteLine("{0} does not match the pattern.", value);
             Console.WriteLine();
          }
       }
    }
    // The example displays the following output:
    //       Canonical matching: 'целый мир' matches the pattern.
    //       ECMAScript matching: целый мир does not match the pattern.
    //       
    //       Canonical matching: 'the whole world' matches the pattern.
    //       ECMAScript matching: 'the whole world' matches the pattern.
    
    Imports System.Text.RegularExpressions
    
    Module Example
       Public Sub Main()
          Dim values() As String = { "целый мир", "the whole world" }
          Dim pattern As String = "\b(\w+\s*)+"
          For Each value In values
             Console.Write("Canonical matching: ")
             If Regex.IsMatch(value, pattern)
                Console.WriteLine("'{0}' matches the pattern.", value)
             Else
                Console.WriteLine("{0} does not match the pattern.", value)
             End If
             
             Console.Write("ECMAScript matching: ")
             If Regex.IsMatch(value, pattern, RegexOptions.ECMAScript)
                Console.WriteLine("'{0}' matches the pattern.", value)
             Else
                Console.WriteLine("{0} does not match the pattern.", value)
             End If
             Console.WriteLine()
          Next
       End Sub
    End Module
    ' The example displays the following output:
    '       Canonical matching: 'целый мир' matches the pattern.
    '       ECMAScript matching: целый мир does not match the pattern.
    '       
    '       Canonical matching: 'the whole world' matches the pattern.
    '       ECMAScript matching: 'the whole world' matches the pattern.
    
  • Grupy przechwytywania odwołujące.Self-referencing capturing groups. Klasa przechwytywania wyrażeń regularnych z odwołaniem wstecznym do siebie musi być aktualizowana przy każdej iteracji przechwytywania.A regular expression capture class with a backreference to itself must be updated with each capture iteration. Jak pokazano na poniższym przykładzie, ta funkcja umożliwia wyrażenia regularnego ((a+)(\1) ?)+ do pasuje do ciągu wejściowego "aa aaaa aaaaaa", korzystając z ECMAScript, ale nie przy wykorzystaniu dopasowania kanonicznego.As the following example shows, this feature enables the regular expression ((a+)(\1) ?)+ to match the input string " aa aaaa aaaaaa " when using ECMAScript, but not when using canonical matching.

    using System;
    using System.Text.RegularExpressions;
    
    public class Example
    {
       static string pattern;
       
       public static void Main()
       {
          string input = "aa aaaa aaaaaa "; 
          pattern = @"((a+)(\1) ?)+";
          
          // Match input using canonical matching.
          AnalyzeMatch(Regex.Match(input, pattern));
          
          // Match input using ECMAScript.
          AnalyzeMatch(Regex.Match(input, pattern, RegexOptions.ECMAScript));
       }   
       
       private static void AnalyzeMatch(Match m)
       {
          if (m.Success)
          {
             Console.WriteLine("'{0}' matches {1} at position {2}.",  
                               pattern, m.Value, m.Index);
             int grpCtr = 0;
             foreach (Group grp in m.Groups)
             {
                Console.WriteLine("   {0}: '{1}'", grpCtr, grp.Value);
                grpCtr++;
                int capCtr = 0;
                foreach (Capture cap in grp.Captures)
                {
                   Console.WriteLine("      {0}: '{1}'", capCtr, cap.Value);
                   capCtr++;
                }
             }
          }
          else
          {
             Console.WriteLine("No match found.");
          }   
          Console.WriteLine();
       }
    }
    // The example displays the following output:
    //    No match found.
    //    
    //    '((a+)(\1) ?)+' matches aa aaaa aaaaaa  at position 0.
    //       0: 'aa aaaa aaaaaa '
    //          0: 'aa aaaa aaaaaa '
    //       1: 'aaaaaa '
    //          0: 'aa '
    //          1: 'aaaa '
    //          2: 'aaaaaa '
    //       2: 'aa'
    //          0: 'aa'
    //          1: 'aa'
    //          2: 'aa'
    //       3: 'aaaa '
    //          0: ''
    //          1: 'aa '
    //          2: 'aaaa '
    
    Imports System.Text.RegularExpressions
    
    Module Example
       Dim pattern As String
       
       Public Sub Main()
          Dim input As String = "aa aaaa aaaaaa " 
          pattern = "((a+)(\1) ?)+"
          
          ' Match input using canonical matching.
          AnalyzeMatch(Regex.Match(input, pattern))
          
          ' Match input using ECMAScript.
          AnalyzeMatch(Regex.Match(input, pattern, RegexOptions.ECMAScript))
       End Sub   
       
       Private Sub AnalyzeMatch(m As Match)
          If m.Success
             Console.WriteLine("'{0}' matches {1} at position {2}.", _ 
                               pattern, m.Value, m.Index)
             Dim grpCtr As Integer = 0
             For Each grp As Group In m.Groups
                Console.WriteLine("   {0}: '{1}'", grpCtr, grp.Value)
                grpCtr += 1
                Dim capCtr As Integer = 0
                For Each cap As Capture In grp.Captures
                   Console.WriteLine("      {0}: '{1}'", capCtr, cap.Value)
                   capCtr += 1
                Next
             Next
          Else
             Console.WriteLine("No match found.")
          End If   
          Console.WriteLine()
       End Sub
    End Module
    ' The example displays the following output:
    '    No match found.
    '    
    '    '((a+)(\1) ?)+' matches aa aaaa aaaaaa  at position 0.
    '       0: 'aa aaaa aaaaaa '
    '          0: 'aa aaaa aaaaaa '
    '       1: 'aaaaaa '
    '          0: 'aa '
    '          1: 'aaaa '
    '          2: 'aaaaaa '
    '       2: 'aa'
    '          0: 'aa'
    '          1: 'aa'
    '          2: 'aa'
    '       3: 'aaaa '
    '          0: ''
    '          1: 'aa '
    '          2: 'aaaa '
    

    Wyrażenie regularne jest zdefiniowane, jak pokazano w poniższej tabeli.The regular expression is defined as shown in the following table.

    WzorzecPattern OpisDescription
    (a+)(a+) Odpowiada literze "a" jeden lub więcej razy.Match the letter "a" one or more times. Jest to druga grupa przechwytywania.This is the second capturing group.
    (\1)(\1) Dopasuj podciąg przechwycony przez pierwszą grupę przechwytywania.Match the substring captured by the first capturing group. Jest to trzecia grupa przechwytywania.This is the third capturing group.
    ?? Dopasowuje zero lub jeden znak spacji.Match zero or one space characters.
    ((a+)(\1) ?)+((a+)(\1) ?)+ Dopasowanie wzorca jednego lub więcej znaki "a następuje ciąg, który pasuje do pierwszej grupy przechwytywania" następuje zero lub jeden obszar znaków, jeden lub więcej razy.Match the pattern of one or more "a" characters followed by a string that matches the first capturing group followed by zero or one space characters one or more times. Jest to pierwsza grupa przechwytywania.This is the first capturing group.
  • Rozdzielczość niejasności między ósemkową zwraca i wprowadza odwołania wsteczne.Resolution of ambiguities between octal escapes and backreferences. W poniższej tabeli podsumowano różnice w ósemkowych w porównaniu z dopasowywania wstecznego interpretacji przez canonical i wyrażeń regularnych ECMAScript.The following table summarizes the differences in octal versus backreference interpretation by canonical and ECMAScript regular expressions.

    Wyrażenie regularneRegular expression Zachowanie kanoniczneCanonical behavior Zachowanie ECMAScriptECMAScript behavior
    \0 następują cyfry ósemkowe 0 do 2\0 followed by 0 to 2 octal digits Interpretuj jako ósemkowy.Interpret as an octal. Na przykład \044 jest zawsze interpretowane jako wartość ósemkowa i oznacza "$".For example, \044 is always interpreted as an octal value and means "$". Takie samo zachowanie.Same behavior.
    \ następuje numer od 1 do 9, bez dodatkowych cyfr dziesiętnych Interpretuj jako odwołanie wsteczne.\ followed by a digit from 1 to 9, followed by no additional decimal digits, Interpret as a backreference. Na przykład \9 zawsze oznacza odwołanie wsteczne nr 9, nawet jeśli dziewiąta grupa przechwytywania nie istnieje.For example, \9 always means backreference 9, even if a ninth capturing group does not exist. Jeśli grupa przechwytywania nie istnieje, analizator składni wyrażeń regularnych zgłasza ArgumentException.If the capturing group does not exist, the regular expression parser throws an ArgumentException. Jeśli przechwytywanie pojedynczą cyfrą dziesiętną grupa istnieje, Utwórz wsteczne odwołanie do tej cyfry.If a single decimal digit capturing group exists, backreference to that digit. W przeciwnym razie interpretuje wartość jako literał.Otherwise, interpret the value as a literal.
    \ następuje numer od 1 do 9, a następnie dodatkowe cyfry dziesiętne Interpretuj cyfry jako wartość dziesiętną.\ followed by a digit from 1 to 9, followed by additional decimal digits Interpret the digits as a decimal value. Jeśli ta grupa przechwytywania istnieje, następuje interpretacja wyrażenia jako odwołanie wsteczne.If that capturing group exists, interpret the expression as a backreference.

    W przeciwnym wypadku interpretuje wiodące cyfry ósemkowe do ósemkowej 377; oznacza to należy rozważyć tylko niskie 8 bitów wartości.Otherwise, interpret the leading octal digits up to octal 377; that is, consider only the low 8 bits of the value. Interpretuj pozostałe cyfry jako literały.Interpret the remaining digits as literals. Na przykład w wyrażeniu \3000, jeśli istnieje grupa przechwytywania 300, następuje interpretacja jako odwołania wstecznego 300; Jeśli grupa przechwytywania 300 nie istnieje, następuje interpretacja jako ósemkowe 300, następuje 0.For example, in the expression \3000, if capturing group 300 exists, interpret as backreference 300; if capturing group 300 does not exist, interpret as octal 300 followed by 0.
    Interpretuj jako odwołanie wsteczne, konwertując dowolną liczbę cyfr jak najbliżej wartość dziesiętnych, która może odwoływać się do przechwytywania.Interpret as a backreference by converting as many digits as possible to a decimal value that can refer to a capture. Jeśli mogą być konwertowane nie cyfry, następuje interpretacja jako wartości ósemkowej za pomocą wiodących cyfr ósemkowych aż do ósemkowej 377; interpretuj pozostałe cyfry jako literały.If no digits can be converted, interpret as an octal by using the leading octal digits up to octal 377; interpret the remaining digits as literals.

Powrót do początkuBack to Top

Porównanie przy użyciu niezmiennej kulturyComparison Using the Invariant Culture

Domyślnie gdy aparat wyrażeń regularnych wykonuje porównania bez uwzględniania wielkości liter, używa konwencji obudowy bieżącej kultury, aby określić równoważne znaki wielkich i małych.By default, when the regular expression engine performs case-insensitive comparisons, it uses the casing conventions of the current culture to determine equivalent uppercase and lowercase characters.

To zachowanie jest jednak niepożądane dla niektórych rodzajów porównań, szczególnie podczas porównywania danych wprowadzonych przez użytkownika z nazwami zasobów systemowych, takich jak hasła, pliki lub adresy URL.However, this behavior is undesirable for some types of comparisons, particularly when comparing user input to the names of system resources, such as passwords, files, or URLs. Poniższy przykład ilustruje taki scenariusz.The following example illustrates such as scenario. Kod jest przeznaczony do blokowania dostępu do dowolnego zasobu, którego adres URL jest poprzedzony elementem FILE:// .The code is intended to block access to any resource whose URL is prefaced with FILE://. Wyrażenie regularne próbuje dopasowanie bez uwzględniania wielkości liter na ciąg przy użyciu wyrażeń regularnych $FILE://.The regular expression attempts a case-insensitive match with the string by using the regular expression $FILE://. Jednak gdy bieżącą kulturą systemu jest tr-TR (Turecki-Turcja), "I" nie jest odpowiednikiem wielkie litery "i".However, when the current system culture is tr-TR (Turkish-Turkey), "I" is not the uppercase equivalent of "i". W wyniku wywołania Regex.IsMatch metoda zwraca false, i jest dozwolony dostęp do pliku.As a result, the call to the Regex.IsMatch method returns false, and access to the file is allowed.

CultureInfo defaultCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");

string input = "file://c:/Documents.MyReport.doc";
string pattern = "FILE://";

Console.WriteLine("Culture-sensitive matching ({0} culture)...", 
                  Thread.CurrentThread.CurrentCulture.Name);
if (Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase))
   Console.WriteLine("URLs that access files are not allowed.");      
else
   Console.WriteLine("Access to {0} is allowed.", input);

Thread.CurrentThread.CurrentCulture = defaultCulture;
// The example displays the following output:
//       Culture-sensitive matching (tr-TR culture)...
//       Access to file://c:/Documents.MyReport.doc is allowed.
Dim defaultCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture = New CultureInfo("tr-TR")

Dim input As String = "file://c:/Documents.MyReport.doc"
Dim pattern As String = "$FILE://"

Console.WriteLine("Culture-sensitive matching ({0} culture)...", _
                  Thread.CurrentThread.CurrentCulture.Name)
If Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase) Then
   Console.WriteLine("URLs that access files are not allowed.")      
Else
   Console.WriteLine("Access to {0} is allowed.", input)
End If

Thread.CurrentThread.CurrentCulture = defaultCulture
' The example displays the following output:
'       Culture-sensitive matching (tr-TR culture)...
'       Access to file://c:/Documents.MyReport.doc is allowed.

Uwaga

Aby uzyskać więcej informacji na temat porównań ciągów, które jest rozróżniana wielkość liter i które używają niezmiennej kultury zobacz najlepsze rozwiązania dotyczące Using Strings.For more information about string comparisons that are case-sensitive and that use the invariant culture, see Best Practices for Using Strings.

Zamiast korzystać z porównania bez uwzględniania wielkości liter bieżącej kultury, można określić RegexOptions.CultureInvariant opcję Ignoruj różnice kulturowe w języku i używać konwencji Niezmienna kultura.Instead of using the case-insensitive comparisons of the current culture, you can specify the RegexOptions.CultureInvariant option to ignore cultural differences in language and to use the conventions of the invariant culture.

Uwaga

Porównanie przy użyciu kultura niezmienna jest dostępne tylko poprzez dostarczenie RegexOptions.CultureInvariant wartość options parametru Regex konstruktora klasy lub statycznej metody dopasowania do wzorca.Comparison using the invariant culture is available only by supplying the RegexOptions.CultureInvariant value to the options parameter of a Regex class constructor or static pattern-matching method. Nie jest dostępna jako opcja wbudowana.It is not available as an inline option.

Poniższy przykład jest identyczny z poprzednim przykładem, chyba że statyczne Regex.IsMatch(String, String, RegexOptions) metoda jest wywoływana z opcji obejmujących RegexOptions.CultureInvariant.The following example is identical to the previous example, except that the static Regex.IsMatch(String, String, RegexOptions) method is called with options that include RegexOptions.CultureInvariant. Nawet wtedy, gdy bieżącą kulturę ustawiono turecki (Turcja), aparat wyrażeń regularnych jest w stanie pomyślnie dopasować elementy "FILE" i "file" i zablokować dostęp do zasobów plików.Even when the current culture is set to Turkish (Turkey), the regular expression engine is able to successfully match "FILE" and "file" and block access to the file resource.

CultureInfo defaultCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");

string input = "file://c:/Documents.MyReport.doc";
string pattern = "FILE://";

Console.WriteLine("Culture-insensitive matching...");
if (Regex.IsMatch(input, pattern, 
                  RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)) 
   Console.WriteLine("URLs that access files are not allowed.");
else
   Console.WriteLine("Access to {0} is allowed.", input);

Thread.CurrentThread.CurrentCulture = defaultCulture;
// The example displays the following output:
//       Culture-insensitive matching...
//       URLs that access files are not allowed.
Dim defaultCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture = New CultureInfo("tr-TR")

Dim input As String = "file://c:/Documents.MyReport.doc"
Dim pattern As String = "$FILE://"

Console.WriteLine("Culture-insensitive matching...")
If Regex.IsMatch(input, pattern, _
               RegexOptions.IgnoreCase Or RegexOptions.CultureInvariant) Then
   Console.WriteLine("URLs that access files are not allowed.")      
Else
   Console.WriteLine("Access to {0} is allowed.", input)
End If
Thread.CurrentThread.CurrentCulture = defaultCulture
' The example displays the following output:
'        Culture-insensitive matching...
'        URLs that access files are not allowed.

Zobacz takżeSee also