Другие конструкции

  • Статья

Регулярные выражения в платформе .NET Framework включают три различные языковые конструкции. Позволяет включить или отключить определенные параметры соответствия в середине шаблона регулярного выражения. Оставшиеся два позволяют включить примечания в регулярное выражение.

Встроенные параметры

Задать или отключить конкретные параметры сопоставления шаблонов для части регулярного выражения можно с помощью синтаксиса

(?imnsx-imnsx)

Список параметров, которые нужно включить, приводится после вопросительного знака, а параметры, которые требуется отключить, перечисляются после знака "минус". В приведенной ниже таблице описывается каждый из этих параметров. Дополнительные сведения о каждом параметре см. в разделе Параметры регулярных выражений.

Параметр

Описание

i

Соответствие без учета регистра.

m

Многострочный режим.

n

Только явные захваты. (Скобки не действуют как захватываемые группы.)

s

Однострочный режим.

x

Игнорировать не преобразованные в escape-последовательность пробелы и разрешить комментарии в режиме x.

Любое изменение параметров регулярных выражений, заданное конструкцией (?imnsx-imnsx), остается в силе до конца содержащей группы.

ПримечаниеПримечание

Конструкция группировки (?imnsx-imnsx:часть выражения) предоставляет части выражения одинаковые функциональные возможности.Дополнительные сведения см. в разделе Конструкции группирования.

В следующем примере параметры i, n и x используются для отключения чувствительности к регистру символов и включения явных захватов, чтобы игнорировать пробелы в шаблоне регулярного выражения в его середине.

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'

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'

В примере определяются два регулярных выражения. Первый, \b(D\w+)\s(d\w+)\b, выделяет два последовательных слова, начинающиеся со строчной буквы d и прописной буквы D. Второе регулярное выражение \b(D\w+)(?ixn) \s (d\w+) \b использует встроенные параметры для изменения этого шаблона, как описано в следующей таблице. Сравнение результатов подтверждает влияние конструкции (?ixn).

Шаблон

Описание

\b

Начало на границе слова.

(D\w+)

Выделяет прописную букву "D" c одной или несколькими последующими буквами. Это первая группа записи.

(?ixn)

С этого момента делайте сравнения без учета регистра, делайте только явные захваты и игнорируйте пробелы в шаблоне регулярного выражения.

\s

Соответствует пробелу.

(d\w+)

Выделяет прописную или строчную букву "d", за которой следует один или несколько букв. Эта группа не записывается, поскольку включен параметр n (явная запись).

\b

Соответствует границе слова.

Встроенное примечание

Конструкция (?# комментарий) позволяет включить встроенные комментарии в регулярное выражение. Обработчик регулярных выражений не использует какую-либо часть комментария при выделении шаблонов, хотя комментарий включается в строку, которая возвращается методом Regex.ToString. Примечание заканчивается первой закрывающей скобкой.

В следующем примере повторяется первый шаблон регулярного выражения из примера, указанного в предыдущем разделе. В регулярное выражение добавляются два встроенных комментария, чтобы указать, учитывается ли в сравнении регистр. Шаблон регулярного выражения \b((?# case-sensitive comparison)D\w+)\s((?#case-insensitive comparison)d\w+)\b определяется следующим образом.

Шаблон

Описание

\b

Начало на границе слова.

(?# case-sensitive comparison)

Комментарий. Не влияет на алгоритм выделения шаблона.

(D\w+)

Выделяет прописную букву "D" c одной или несколькими последующими буквами. Это первая группа записи.

\s

Соответствует пробелу.

(?ixn)

С этого момента делайте сравнения без учета регистра, делайте только явные захваты и игнорируйте пробелы в шаблоне регулярного выражения.

(?#case-insensitive comparison)

Комментарий. Не влияет на алгоритм выделения шаблона.

(d\w+)

Выделяет прописную или строчную букву "d", за которой следует один или несколько букв. Это вторая группа записи.

\b

Соответствует границе слова.

 
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

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

Комментарий в конце строки.

Знак номера (#) помечает комментарий режима x, который начинается символом #, не преобразованным в escape-последовательность, в конце шаблона регулярного выражения и продолжается до конца строки. Для использования этой конструкции следует включить параметр x (во встроенных параметрах) или передать значение RegexOptions.IgnorePatternWhitespace в параметр option при создании экземпляра Regex или вызове статического метода Regex.

В следующем примере показана конструкция комментария в конце строки. Определяет, является ли строка составного форматирования строкой, которая включает по крайней мере один элемент формата. В следующей таблице описаны конструкции шаблона регулярного выражения.

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

Шаблон

Описание

\{

Совпадает с открывающей фигурной скобкой.

\d+

Совпадение с одной или несколькими десятичными цифрами.

(,-*\d+)*

Выделить ноль или одно вхождение запятой, за которой следует минус (необязательно), за которым идет одна или несколько десятичных цифр.

(\:\w{1,4}?)*

Выделить ноль или одно вхождение двоеточие, за которым следуют как можно меньшее число символов пробела (от одного до четырех).

(?#case insensitive comparison)

Встроенное примечание. Не влияет на алгоритм выделения шаблона.

\}

Выделяет закрывающую фигурную скобку.

(?x)

Включите игнорирование параметра пробела шаблона, чтобы распознавался комментарий в конце строки.

# Looks for 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.

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.

Обратите внимание, что вместо предоставления конструкции (?x) в регулярном выражении комментарий также можно распознать путем вызова метода Regex.IsMatch(String, String, RegexOptions) и передачи ему значения перечисления RegexOptions.IgnorePatternWhitespace.

См. также

Основные понятия

Элементы языка регулярных выражений