Inne konstrukcje w wyrażeniach regularnychMiscellaneous Constructs in Regular Expressions

Wyrażenia regularne w .NET obejmują trzy konstrukcji językowych różne.Regular expressions in .NET include three miscellaneous language constructs. Jeden pozwala włączyć lub wyłączyć określonego opcje dopasowania w środku wzorca wyrażenia regularnego.One lets you enable or disable particular matching options in the middle of a regular expression pattern. Dwóch pozostałych pozwala na uwzględnianie komentarzy w wyrażeniu regularnym.The remaining two let you include comments in a regular expression.

Opcje określane w tekścieInline Options

Można ustawić lub wyłączyć określony wzorzec dopasowywania opcje dla części wyrażenia regularnego przy użyciu składniYou can set or disable specific pattern matching options for part of a regular expression by using the syntax

(?imnsx-imnsx)  

Możesz wyświetlić listę opcje, które chcesz włączyć po znaku zapytania, a także opcje, które chcesz wyłączyć po znaku minus.You list the options you want to enable after the question mark, and the options you want to disable after the minus sign. W tabeli poniżej opisano wszystkie opcje.The following table describes each option. Aby uzyskać więcej informacji na temat poszczególnych opcji, zobacz Regular Expression Options.For more information about each option, see Regular Expression Options.

OpcjaOption OpisDescription
i Dopasowywanie bez uwzględniania wielkości liter.Case-insensitive matching.
m Tryb wielowierszowy.Multiline mode.
n Tylko jawne przechwytywania.Explicit captures only. (Nawias mają nie zachowywać się jak grupy przechwytywania.)(Parentheses do not act as capturing groups.)
s Trybu jednowierszowego.Single-line mode.
x Ignoruj niekodowany biały znak i umożliwiają komentarz trybu x.Ignore unescaped white space, and allow x-mode comments.

Wszelkie zmiany w opcje wyrażeń regularnych zdefiniowane przez (?imnsx-imnsx) konstruowania pozostają w mocy aż do zakończenia otaczającego grupy.Any change in regular expression options defined by the (?imnsx-imnsx) construct remains in effect until the end of the enclosing group.

Uwaga

(?imnsx-imnsx: Podwyrażenie ) konstrukcja grupująca zapewnia identyczne funkcje podwyrażenia.The (?imnsx-imnsx:subexpression) grouping construct provides identical functionality for a subexpression. Aby uzyskać więcej informacji, zobacz Konstrukcje grupujące.For more information, see Grouping Constructs.

W poniższym przykładzie użyto i, n, i x opcje umożliwiające ignorowanie wielkości liter i jawne przechwytywania i ignoruje biały znak we wzorcu wyrażenia regularnego w trakcie wykonywania wyrażenia regularnego.The following example uses the i, n, and x options to enable case insensitivity and explicit captures, and to ignore white space in the regular expression pattern in the middle of a regular expression.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern; 
      string input = "double dare double Double a Drooling dog The Dreaded Deep";
      
      pattern = @"\b(D\w+)\s(d\w+)\b";
      // Match pattern using default options.
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
            for (int ctr = 1; ctr < match.Groups.Count; ctr++) 
               Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
      }
      Console.WriteLine();
      
      // Change regular expression pattern to include options.
      pattern = @"\b(D\w+)(?ixn) \s (d\w+) \b";
      // Match new pattern with options. 
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
            for (int ctr = 1; ctr < match.Groups.Count; ctr++) 
               Console.WriteLine("   Group {0}: '{1}'", ctr, match.Groups[ctr].Value);
      }
   }
}
// The example displays the following output:
//       Drooling dog
//          Group 1: Drooling
//          Group 2: dog
//       
//       Drooling dog
//          Group 1: 'Drooling'
//       Dreaded Deep
//          Group 1: 'Dreaded'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String 
      Dim input As String = "double dare double Double a Drooling dog The Dreaded Deep"
      
      pattern = "\b(D\w+)\s(d\w+)\b"
      ' Match pattern using default options.
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
         If match.Groups.Count > 1 Then
            For ctr As Integer = 1 To match.Groups.Count - 1 
               Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
            Next
         End If
      Next
      Console.WriteLine()
      
      ' Change regular expression pattern to include options.
      pattern = "\b(D\w+)(?ixn) \s (d\w+) \b"
      ' Match new pattern with options. 
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
         If match.Groups.Count > 1 Then
            For ctr As Integer = 1 To match.Groups.Count - 1 
               Console.WriteLine("   Group {0}: '{1}'", ctr, match.Groups(ctr).Value)
            Next
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       Drooling dog
'          Group 1: Drooling
'          Group 2: dog
'       
'       Drooling dog
'          Group 1: 'Drooling'
'       Dreaded Deep
'          Group 1: 'Dreaded'

W przykładzie zdefiniowano dwóch wyrażeń regularnych.The example defines two regular expressions. Pierwsza strona, \b(D\w+)\s(d\w+)\b, dopasowuje dwa kolejne wyrazy rozpoczynające się od wielkiej "D" i "d" małymi literami.The first, \b(D\w+)\s(d\w+)\b, matches two consecutive words that begin with an uppercase "D" and a lowercase "d". Drugie wyrażenie regularne \b(D\w+)(?ixn) \s (d\w+) \b, używa opcji wbudowanej do modyfikowania tego wzorca, zgodnie z opisem w poniższej tabeli.The second regular expression, \b(D\w+)(?ixn) \s (d\w+) \b, uses inline options to modify this pattern, as described in the following table. Porównanie wyników potwierdza efekt (?ixn) konstruowania.A comparison of the results confirms the effect of the (?ixn) construct.

WzorzecPattern OpisDescription
\b Rozpoczyna na granicy wyrazu.Start at a word boundary.
(D\w+) Dopasowuje wielkiej litery "D", po którym następuje co najmniej jeden znak słowa.Match a capital "D" followed by one or more word characters. Jest to pierwsza grupa przechwytywania.This is the first capture group.
(?ixn) Od tej pory na marki porównania bez uwzględniania wielkości liter upewnij tylko jawne przechwytuje i Ignoruj biały znak we wzorcu wyrażenia regularnego.From this point on, make comparisons case-insensitive, make only explicit captures, and ignore white space in the regular expression pattern.
\s Dopasowuje znak odstępu.Match a white-space character.
(d\w+) Dopasowuje wielkimi lub małymi literami "d" następuje jeden lub więcej znaków słowa.Match an uppercase or lowercase "d" followed by one or more word characters. Ta grupa nie jest przechwytywany, ponieważ n została włączona opcja (jawne przechwytywania)...This group is not captured because the n (explicit capture) option was enabled..
\b Dopasowuje granicę wyrazu.Match a word boundary.

Komentarz w tekścieInline Comment

(?# Komentarz ) konstrukcja pozwala dołączyć komentarz w tekście w wyrażeń regularnych.The (?# comment) construct lets you include an inline comment in a regular expression. Aparat wyrażeń regularnych nie korzysta z dowolnej części komentarz w dopasowywania do wzorca, chociaż komentarz znajduje się w ciągu, który jest zwracany przez Regex.ToString metody.The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. Komentarz kończy się przy pierwszym nawiasie zamykającym.The comment ends at the first closing parenthesis.

Poniższy przykład jest powtarzany wzorca pierwszego wyrażenia regularnego z przykładu w poprzedniej sekcji.The following example repeats the first regular expression pattern from the example in the previous section. Dodaje dwa komentarze w tekście do wyrażenia regularnego, aby wskazać, czy wynikiem porównania jest uwzględniana wielkość liter.It adds two inline comments to the regular expression to indicate whether the comparison is case-sensitive. Wzorzec wyrażenia regularnego \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b, jest zdefiniowana w następujący sposób.The regular expression pattern, \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b, is defined as follows.

WzorzecPattern OpisDescription
\b Rozpoczyna na granicy wyrazu.Start at a word boundary.
(?# case-sensitive comparison) Komentarz.A comment. Nie ma wpływu na zachowanie dopasowania do wzorca.It does not affect pattern-matching behavior.
(D\w+) Dopasowuje wielkiej litery "D", po którym następuje co najmniej jeden znak słowa.Match a capital "D" followed by 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.
(?ixn) Od tej pory na marki porównania bez uwzględniania wielkości liter upewnij tylko jawne przechwytuje i Ignoruj biały znak we wzorcu wyrażenia regularnego.From this point on, make comparisons case-insensitive, make only explicit captures, and ignore white space in the regular expression pattern.
(?#case-insensitive comparison) Komentarz.A comment. Nie ma wpływu na zachowanie dopasowania do wzorca.It does not affect pattern-matching behavior.
(d\w+) Dopasowuje wielkimi lub małymi literami "d" następuje jeden lub więcej znaków słowa.Match an uppercase or lowercase "d" followed by one or more word characters. Jest to druga grupa przechwytywania.This is the second capture group.
\b Dopasowuje granicę wyrazu.Match a word boundary.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b";
      Regex rgx = new Regex(pattern);
      string input = "double dare double Double a Drooling dog The Dreaded Deep";

      Console.WriteLine("Pattern: " + pattern.ToString());
      // Match pattern using default options.
      foreach (Match match in rgx.Matches(input))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
         {
            for (int ctr = 1; ctr <match.Groups.Count; ctr++) 
               Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
         }
      }
   }
}
// The example displays the following output:
//    Pattern: \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comp
//    arison)d\w+)\b
//    Drooling dog
//       Group 1: Drooling
//    Dreaded Deep
//       Group 1: Dreaded
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b"
      Dim rgx As New Regex(pattern)
      Dim input As String = "double dare double Double a Drooling dog The Dreaded Deep"

      Console.WriteLine("Pattern: " + pattern.ToString())
      ' Match pattern using default options.
      For Each match As Match In rgx.Matches(input)
         Console.WriteLine(match.Value)
         If match.Groups.Count > 1 Then
            For ctr As Integer = 1 To match.Groups.Count - 1 
               Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
            Next
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'    Pattern: \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comp
'    arison)d\w+)\b
'    Drooling dog
'       Group 1: Drooling
'    Dreaded Deep
'       Group 1: Dreaded

Komentarz do końca wierszaEnd-of-Line Comment

Znak numeru (#) oznacza komentarz trybu x, która rozpoczyna się od znaku # o niezmienionym znaczeniu na końcu wzorca wyrażenia regularnego i jest kontynuowany aż do końca wiersza.A number sign (#)marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. Aby użyć tej konstrukcji, musisz albo Włącz x opcji (za pomocą opcji wbudowanych) lub podać RegexOptions.IgnorePatternWhitespace wartość option parametru podczas tworzenia wystąpienia Regex obiektu lub wywoływania statycznej Regex metody.To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method.

W poniższym przykładzie pokazano konstrukcję końca wiersza komentarza.The following example illustrates the end-of-line comment construct. Określa, czy ciąg jest ciąg formatu złożonego, który zawiera co najmniej jeden element formatu.It determines whether a string is a composite format string that includes at least one format item. W poniższej tabeli opisano konstrukcje we wzorcu wyrażenia regularnego:The following table describes the constructs in the regular expression pattern:

\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item.

WzorzecPattern OpisDescription
\{ Zgodny z nawiasem otwierającym.Match an opening brace.
\d+ Dopasowanie do co najmniej jednej cyfry dziesiętnej.Match one or more decimal digits.
(,-*\d+)* Dopasowuje wystąpienia zero lub jeden przecinek, następuje opcjonalny znak minusa, następuje jeden lub więcej cyfr dziesiętnych.Match zero or one occurrence of a comma, followed by an optional minus sign, followed by one or more decimal digits.
(\:\w{1,4}?)* Dopasowuje zero lub jeden wystąpienie dwukropek i 1 do 4, ale tak małą możliwie białych znaków.Match zero or one occurrence of a colon, followed by one to four, but as few as possible, white-space characters.
\} Dopasowuje zamykającego nawiasu klamrowego.Match a closing brace.
(?x) Włącz opcję Ignoruj wzorca odstępu komentarz końca wiersza zostanie rozpoznana.Enable the ignore pattern white-space option so that the end-of-line comment will be recognized.
# Looks for a composite format item. Komentarz do końca wiersza.An end-of-line comment.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item.";
      string input = "{0,-3:F}";
      Console.WriteLine("'{0}':", input);
      if (Regex.IsMatch(input, pattern))
         Console.WriteLine("   contains a composite format item.");
      else
         Console.WriteLine("   does not contain a composite format item.");
   }
}
// The example displays the following output:
//       '{0,-3:F}':
//          contains a composite format item.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item."
      Dim input As String = "{0,-3:F}"
      Console.WriteLine("'{0}':", input)
      If Regex.IsMatch(input, pattern) Then
         Console.WriteLine("   contains a composite format item.")
      Else
         Console.WriteLine("   does not contain a composite format item.")
      End If
   End Sub
End Module
' The example displays the following output:
'       '{0,-3:F}':
'          contains a composite format item.

Należy zauważyć, że zamiast podawać (?x) konstruowania w wyrażeniu regularnym komentarz może również zostały uznane przez wywołanie metody Regex.IsMatch(String, String, RegexOptions) metody i przekazanie do niej RegexOptions.IgnorePatternWhitespace wartość wyliczenia.Note that, instead of providing the (?x) construct in the regular expression, the comment could also have been recognized by calling the Regex.IsMatch(String, String, RegexOptions) method and passing it the RegexOptions.IgnorePatternWhitespace enumeration value.

Zobacz takżeSee also