Классы символов в регулярных выражениях

Класс символов определяет набор символов, любой из которых может присутствовать во входной строке для успешного сопоставления. Язык регулярных выражений в .NET поддерживает следующие классы символов:

• Положительные группы символов. Входная строка должна содержать символ из указанного набора. Дополнительные сведения см. в разделе Положительная группа символов.

• Отрицательные группы символов. Входная строка не должна содержать символ из указанного набора. Дополнительные сведения см. в разделе Отрицательная группа символов.

• Любой символ. Символ . (точка) в регулярных выражениях является подстановочным знаком, который соответствует всем символам, кроме \n. Дополнительные сведения см. в разделе Любой символ.

• Общая категория Юникода или именованный блок. Входная строка должна содержать символ из определенной категории Юникода или непрерывного диапазона символов Юникода. Дополнительные сведения см. в разделе Категория Юникода или блок Юникода.

• Отрицательная общая категория Юникода или именованный блок. Входная строка не должна содержать символ из определенной категории Юникода или непрерывного диапазона символов Юникода. Дополнительные сведения см. в разделе Отрицательная категория Юникода или блок Юникода.

• Словообразующий символ. Входная строка может содержать символ, относящийся к любой категории Юникода, соответствующей символам в словах. Дополнительные сведения см. в разделе Словообразующий символ.

• Несловообразующий символ. Входная строка может содержать символ, относящийся к любой категории Юникода, не соответствующей словообразующим символам. Дополнительные сведения см. в разделе Несловообразующий символ.

• Символ пробела. Входная строка может содержать любой разделитель Юникода, а также любой из множества управляющих символов. Дополнительные сведения см. в разделе Символ пробела.

• Символ, не являющийся пробелом. Входная строка может содержать любой символ, кроме пробела. Дополнительные сведения см. в разделе Символ, не являющийся пробелом.

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

• Недесятичная цифра. Входная строка может содержать любой символ, кроме десятичных цифр Юникода. Дополнительные сведения см. в разделе Десятичная цифра.

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

Положительная группа символов: [ ]

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

Синтаксис для указания списка отдельных символов выглядит следующим образом:

[*character_group*]

Здесь character_group — это список отдельных символов, которые могут присутствовать во входной строке для успешного сопоставления. character_group может включать в себя любое сочетание литеральных символов, escape-символов или классов символов.

Синтаксис для указания диапазона символов выглядит следующим образом:

[firstCharacter-lastCharacter]

Здесь firstCharacter — это символ, с которого начинается диапазон, а lastCharacter — символ, которым он заканчивается. Диапазон символов — это непрерывная последовательность знаков, которая задается указанием первого и последнего знака в последовательности и дефиса между ними. Два знака являются смежными, если они имеют соседние кодовые точки в Юникоде. firstCharacter должен быть символом с самой нижней кодовой точкой, а lastCharacter должен быть символом с самой высокой кодовой точкой.

Чтобы включить дефис как непериферный член группы символов, побежайте его. Например, чтобы создать группу символов для символа a и символов из - /, правильный синтаксис имеет значение [a\--/].

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

В следующем примере определена положительная группа знаков, которая содержит символы "a" и "e", таким образом, чтобы входная строка содержала слова grey или gray и еще одно слово.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"gr[ae]y\s\S+?[\s\p{P}]";
      string input = "The gray wolf jumped over the grey wall.";
      MatchCollection matches = Regex.Matches(input, pattern);
      foreach (Match match in matches)
         Console.WriteLine($"'{match.Value}'");
   }
}
// The example displays the following output:
//       'gray wolf '
//       'grey wall.'

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "gr[ae]y\s\S+?[\s\p{P}]"
        Dim input As String = "The gray wolf jumped over the grey wall."
        Dim matches As MatchCollection = Regex.Matches(input, pattern)
        For Each match As Match In matches
            Console.WriteLine($"'{match.Value}'")
        Next
    End Sub
End Module
' The example displays the following output:
'       'gray wolf '
'       'grey wall.'

Регулярное выражение gr[ae]y\s\S+?[\s|\p{P}] определяется следующим образом:

В следующем примере выделяются слова, начинающиеся с любой прописной буквы. Вложенное выражение [A-Z] представляет диапазон прописных букв от A до Z.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[A-Z]\w*\b";
      string input = "A city Albany Zulu maritime Marseilles";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       A
//       Albany
//       Zulu
//       Marseilles

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b[A-Z]\w*\b"
        Dim input As String = "A city Albany Zulu maritime Marseilles"
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
        Next
    End Sub
End Module

Определение регулярного выражения \b[A-Z]\w*\b показано в таблице ниже.

Отрицательная группа символов: [^]

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

Синтаксис для указания списка отдельных символов выглядит следующим образом:

[*^character_group*]

Здесь character_group — это список отдельных символов, которые не могут присутствовать во входной строке для успешного сопоставления. character_group может включать в себя любое сочетание литеральных символов, escape-символов или классов символов.

Синтаксис для указания диапазона символов выглядит следующим образом:

[^*firstCharacter*-*lastCharacter*]

Здесь firstCharacter — это символ, с которого начинается диапазон, а lastCharacter — символ, которым он заканчивается. Диапазон символов — это непрерывная последовательность знаков, которая задается указанием первого и последнего знака в последовательности и дефиса между ними. Два знака являются смежными, если они имеют соседние кодовые точки в Юникоде. firstCharacter должен быть символом с самой нижней кодовой точкой, а lastCharacter должен быть символом с самой высокой кодовой точкой.

Два или более диапазона знаков могут быть объединены. Например, чтобы задать диапазон десятичных цифр от "0" до "9", диапазон строчных букв от "a" до "f" и диапазон прописных букв от "A" до "F" используйте строку [0-9a-fA-F].

Начальный знак вставки (^) отрицательной группы символов является обязательным и указывает на то, что группа знаков является отрицательной, а не положительной.

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

Следующий пример соответствует любому слову, начинающемуся с символов "th", за которыми нет символа "o".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bth[^o]\w+\b";
      string input = "thought thing though them through thus thorough this";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       thing
//       them
//       through
//       thus
//       this

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\bth[^o]\w+\b"
        Dim input As String = "thought thing though them through thus " + _
                              "thorough this"
        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:
'       thing
'       them
'       through
'       thus
'       this

Определение регулярного выражения \bth[^o]\w+\b показано в таблице ниже.

Любой символ: .

Символ периода (.) соответствует любому символу, кроме \n (символа новой строки), со следующими двумя квалификациями:

• Если шаблон регулярного выражения изменяется параметром RegexOptions.Singleline или если часть этого шаблона, содержащая класс символов ., изменяется параметром s, то . соответствует любому символу. Для получения дополнительной информации см. Regular Expression Options.

  В следующем примере показано различное поведение класса символов . по умолчанию и с параметром RegexOptions.Singleline. Регулярное выражение ^.+ начинается с начала строки и соответствует любому знаку. По умолчанию совпадение заканчивается в конце первой строки; Шаблон регулярного выражения соответствует возвращаемой символу каретки, \rно он не соответствует \n. Поскольку параметр RegexOptions.Singleline интерпретирует всю входную строку как единую строку, он сопоставляет каждый символ в строке ввода, включая \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\.
  

• Точка в положительной или отрицательной группе символов рассматривается как литеральный символ точки, а не как класс символов. Дополнительные сведения см. в разделах Положительная группа символов и Отрицательная группа символов ранее в этой статье. В следующем примере представлено определение регулярного выражения, содержащее символ точки (.) как класс символов и как член положительной группы символов. Регулярное выражение \b.*[.?!;:](\s|\z) начинается на границе слова, выделяет все символы, пока не встретится один из пяти знаков препинания (включая точку), после чего выделяет символ пробела или конца строки.

  using System;
  using System.Text.RegularExpressions;
  
  public class Example
  {
     public static void Main()
     {
        string pattern = @"\b.*[.?!;:](\s|\z)";
        string input = "this. what: is? go, thing.";
        foreach (Match match in Regex.Matches(input, pattern))
           Console.WriteLine(match.Value);
     }
  }
  // The example displays the following output:
  //       this. what: is? go, thing.
  

  Imports System.Text.RegularExpressions
  
  Module Example
      Public Sub Main()
          Dim pattern As STring = "\b.*[.?!;:](\s|\z)"
          Dim input As String = "this. what: is? go, thing."
          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. what: is? go, thing.
  

Категория Юникода или блок Юникода: \p{}

В стандарте Юникода каждому символу присваивается общая категория. Например, определенный символ может быть прописной буквой (категория Lu), десятичной цифрой (категория Nd), математическим символом (категория Sm) или разделителем абзацев (категория Zl). Определенные наборы символов стандарта Юникод также занимают некоторый диапазон или блок последовательных кодовых точек. Например, базовая латинская кодировка находится в диапазоне от \u0000 до \u007F, а арабская кодировка находится в диапазоне от \u0600 до \u06FF.

Конструкция регулярного выражения

\p{ имя }

соответствует любым символам, которые относятся к общей категории Юникода или именованному блоку, где name — сокращенное название категории или имя блока. Список сокращений категорий см. в подразделе Поддерживаемые общие категории Юникода далее в этом разделе. Список именованных блоков см. в подразделе Поддерживаемые именованные блоки далее в этом разделе.

В примере ниже конструкция \p{name} используется для выделения общей категории Юникода (в данном случае Pd, т. е. категории знаков препинания и тире) и именованного блока (IsGreek и IsBasicLatin).

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+";
      string input = "Κατα Μαθθαίον - The Gospel of Matthew";

      Console.WriteLine(Regex.IsMatch(input, pattern));        // Displays True.
   }
}

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+"
        Dim input As String = "Κατα Μαθθαίον - The Gospel of Matthew"

        Console.WriteLine(Regex.IsMatch(input, pattern))         ' Displays True.
    End Sub
End Module

Определение регулярного выражения \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ показано в таблице ниже.

Отрицательная категория Юникода или блок Юникода: \P{}

В стандарте Юникода каждому символу присваивается общая категория. Например, определенный символ может быть прописной буквой (категория Lu), десятичной цифрой (категория Nd), математическим символом (категория Sm) или разделителем абзацев (категория Zl). Определенные наборы символов стандарта Юникод также занимают некоторый диапазон или блок последовательных кодовых точек. Например, базовая латинская кодировка находится в диапазоне от \u0000 до \u007F, а арабская кодировка находится в диапазоне от \u0600 до \u06FF.

Конструкция регулярного выражения

\P{ имя }

соответствует любым символам, которые не относятся к общей категории Юникода или именованному блоку, где name — сокращенное название категории или имя блока. Список сокращений категорий см. в подразделе Поддерживаемые общие категории Юникода далее в этом разделе. Список именованных блоков см. в подразделе Поддерживаемые именованные блоки далее в этом разделе.

В примере ниже конструкция \P{name} используется для удаления любых символов валют (в данном случае Sc, т. е. категории символов и валют) из числовых строк.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\P{Sc})+";

      string[] values = { "$164,091.78", "£1,073,142.68", "73¢", "€120" };
      foreach (string value in values)
         Console.WriteLine(Regex.Match(value, pattern).Value);
   }
}
// The example displays the following output:
//       164,091.78
//       1,073,142.68
//       73
//       120

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "(\P{Sc})+"

        Dim values() As String = {"$164,091.78", "£1,073,142.68", "73¢", "€120"}
        For Each value As String In values
            Console.WriteLine(Regex.Match(value, pattern).Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       164,091.78
'       1,073,142.68
'       73
'       120

Шаблон регулярного выражения (\P{Sc})+ выделяет один или несколько символов, которые не являются символами валют. Это позволяет удалить любой символ валюты из строки результата.

Словообразующий символ: \w

\w соответствует любому словообразующему символу. Словообразующий символ входит во все категории Юникода, перечисленные в следующей таблице.

Если задано поведение, совместимое с ECMAScript, то параметр \w эквивалентен [a-zA-Z_0-9]. Информацию о регулярных выражениях ECMAScript см. в подразделе "Поведение сопоставления ECMAScript" раздела Параметры регулярных выражений.

В примере ниже элемент языка \w используется для выделения повторяющихся символов в слове. В примере определяется шаблон регулярного выражения (\w)\1, который можно интерпретировать указанным ниже образом.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w)\1";
      string[] words = { "trellis", "seer", "latter", "summer",
                         "hoarse", "lesser", "aardvark", "stunned" };
      foreach (string word in words)
      {
         Match match = Regex.Match(word, pattern);
         if (match.Success)
            Console.WriteLine("'{0}' found in '{1}' at position {2}.",
                              match.Value, word, match.Index);
         else
            Console.WriteLine("No double characters in '{0}'.", word);
      }
   }
}
// The example displays the following output:
//       'll' found in 'trellis' at position 3.
//       'ee' found in 'seer' at position 1.
//       'tt' found in 'latter' at position 2.
//       'mm' found in 'summer' at position 2.
//       No double characters in 'hoarse'.
//       'ss' found in 'lesser' at position 2.
//       'aa' found in 'aardvark' at position 0.
//       'nn' found in 'stunned' at position 3.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "(\w)\1"
        Dim words() As String = {"trellis", "seer", "latter", "summer", _
                                  "hoarse", "lesser", "aardvark", "stunned"}
        For Each word As String In words
            Dim match As Match = Regex.Match(word, pattern)
            If match.Success Then
                Console.WriteLine("'{0}' found in '{1}' at position {2}.", _
                                  match.Value, word, match.Index)
            Else
                Console.WriteLine("No double characters in '{0}'.", word)
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       'll' found in 'trellis' at position 3.
'       'ee' found in 'seer' at position 1.
'       'tt' found in 'latter' at position 2.
'       'mm' found in 'summer' at position 2.
'       No double characters in 'hoarse'.
'       'ss' found in 'lesser' at position 2.
'       'aa' found in 'aardvark' at position 0.
'       'nn' found in 'stunned' at position 3.

Несловообразующий символ: \W

\W соответствует любому несловообразующему символу. Элемент языка \W эквивалентен следующему классу символов:

[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]

Другими словами, он соответствует любому символу, за исключением символов в категории Юникода, перечисленных в следующей таблице.

Если задано поведение, совместимое с ECMAScript, то параметр \W эквивалентен [^a-zA-Z_0-9]. Информацию о регулярных выражениях ECMAScript см. в подразделе "Поведение сопоставления ECMAScript" раздела Параметры регулярных выражений.

В примере ниже показан класс символов \W. Он определяет шаблон регулярного выражения \b(\w+)(\W){1,2}, выделяющий слово, за которым следует один или два несловообразующих символа, например пробелы или знаки препинания. Возможные интерпретации регулярного выражения показаны в следующей таблице.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)(\W){1,2}";
      string input = "The old, grey mare slowly walked across the narrow, green pasture.";
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         Console.Write("   Non-word character(s):");
         CaptureCollection captures = match.Groups[2].Captures;
         for (int ctr = 0; ctr < captures.Count; ctr++)
             Console.Write(@"'{0}' (\u{1}){2}", captures[ctr].Value,
                           Convert.ToUInt16(captures[ctr].Value[0]).ToString("X4"),
                           ctr < captures.Count - 1 ? ", " : "");
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       The
//          Non-word character(s):' ' (\u0020)
//       old,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       grey
//          Non-word character(s):' ' (\u0020)
//       mare
//          Non-word character(s):' ' (\u0020)
//       slowly
//          Non-word character(s):' ' (\u0020)
//       walked
//          Non-word character(s):' ' (\u0020)
//       across
//          Non-word character(s):' ' (\u0020)
//       the
//          Non-word character(s):' ' (\u0020)
//       narrow,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       green
//          Non-word character(s):' ' (\u0020)
//       pasture.
//          Non-word character(s):'.' (\u002E)

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\w+)(\W){1,2}"
        Dim input As String = "The old, grey mare slowly walked across the narrow, green pasture."
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
            Console.Write("   Non-word character(s):")
            Dim captures As CaptureCollection = match.Groups(2).Captures
            For ctr As Integer = 0 To captures.Count - 1
                Console.Write("'{0}' (\u{1}){2}", captures(ctr).Value, _
                              Convert.ToUInt16(captures(ctr).Value.Chars(0)).ToString("X4"), _
                              If(ctr < captures.Count - 1, ", ", ""))
            Next
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output:
'       The
'          Non-word character(s):' ' (\u0020)
'       old,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       grey
'          Non-word character(s):' ' (\u0020)
'       mare
'          Non-word character(s):' ' (\u0020)
'       slowly
'          Non-word character(s):' ' (\u0020)
'       walked
'          Non-word character(s):' ' (\u0020)
'       across
'          Non-word character(s):' ' (\u0020)
'       the
'          Non-word character(s):' ' (\u0020)
'       narrow,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       green
'          Non-word character(s):' ' (\u0020)
'       pasture.
'          Non-word character(s):'.' (\u002E)

Поскольку объект Group для второй группы записи содержит только один захваченный несловообразующий символ, в примере извлекаются все захваченные несловообразующие символы из объекта CaptureCollection, который возвращается свойством Group.Captures.

Символ пробела: \s

\s соответствует любому символу пробела. Это эквивалентно управляющим последовательностям и категориям Юникода, перечисленным в следующей таблице.

Если задано поведение, совместимое с ECMAScript, то параметр \s эквивалентен [ \f\n\r\t\v]. Информацию о регулярных выражениях ECMAScript см. в подразделе "Поведение сопоставления ECMAScript" раздела Параметры регулярных выражений.

В примере ниже показан класс символов \s. Он определяет шаблон регулярного выражения \b\w+(e)?s(\s|$), выделяющий слово, заканчивающееся на "s" или "es", за которым следует знак пробела или конец входной строки. Возможные интерпретации регулярного выражения показаны в следующей таблице.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+(e)?s(\s|$)";
      string input = "matches stores stops leave leaves";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       matches
//       stores
//       stops
//       leaves

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b\w+(e)?s(\s|$)"
        Dim input As String = "matches stores stops leave leaves"
        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:
'       matches
'       stores
'       stops
'       leaves

Символ, не являющийся пробелом: \S

\S соответствует любому символу, не являющемуся пробелом. Он эквивалентен шаблону регулярного выражения [^\f\n\r\t\v\x85\p{Z}] или противоположному шаблону, эквивалентному \s, выделяющему символы пробела. Дополнительные сведения см. в разделе Символ пробела: \s.

Если задано поведение, совместимое с ECMAScript, то параметр \S эквивалентен [^ \f\n\r\t\v]. Информацию о регулярных выражениях ECMAScript см. в подразделе "Поведение сопоставления ECMAScript" раздела Параметры регулярных выражений.

В примере ниже показан элемент языка \S. Шаблон регулярного выражения \b(\S+)\s? выделяет строки, разделенные символами пробела. Второй элемент в объекте GroupCollection содержит совпадающую строку. Возможные интерпретации регулярного выражения показаны в следующей таблице.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\S+)\s?";
      string input = "This is the first sentence of the first paragraph. " +
                            "This is the second sentence.\n" +
                            "This is the only sentence of the second paragraph.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Groups[1]);
   }
}
// The example displays the following output:
//    This
//    is
//    the
//    first
//    sentence
//    of
//    the
//    first
//    paragraph.
//    This
//    is
//    the
//    second
//    sentence.
//    This
//    is
//    the
//    only
//    sentence
//    of
//    the
//    second
//    paragraph.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\S+)\s?"
        Dim input As String = "This is the first sentence of the first paragraph. " + _
                              "This is the second sentence." + vbCrLf + _
                              "This is the only sentence of the second paragraph."
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Groups(1))
        Next
    End Sub
End Module
' The example displays the following output:
'    This
'    is
'    the
'    first
'    sentence
'    of
'    the
'    first
'    paragraph.
'    This
'    is
'    the
'    second
'    sentence.
'    This
'    is
'    the
'    only
'    sentence
'    of
'    the
'    second
'    paragraph.

Десятичная цифра: \d

\d соответствует любой десятичной цифре. Он эквивалентен шаблону регулярного выражения \p{Nd}, который включает стандартные десятичные цифры 0–9, а также десятичные цифры из некоторых других наборов символов.

Если задано поведение, совместимое с ECMAScript, то параметр \d эквивалентен [0-9]. Информацию о регулярных выражениях ECMAScript см. в подразделе "Поведение сопоставления ECMAScript" раздела Параметры регулярных выражений.

В примере ниже показан элемент языка \d. Проверяет, представляет ли входная строка допустимый телефонный номер в США и Канаде. Шаблон регулярного выражения ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ определяется, как показано в следующей таблице.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$";
      string[] inputs = { "111 111-1111", "222-2222", "222 333-444",
                          "(212) 111-1111", "111-AB1-1111",
                          "212-111-1111", "01 999-9999" };

      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern))
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       111 111-1111: matched
//       222-2222: matched
//       222 333-444: match failed
//       (212) 111-1111: matched
//       111-AB1-1111: match failed
//       212-111-1111: matched
//       01 999-9999: match failed

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$"
        Dim inputs() As String = {"111 111-1111", "222-2222", "222 333-444", _
                                   "(212) 111-1111", "111-AB1-1111", _
                                   "212-111-1111", "01 999-9999"}

        For Each input As String In inputs
            If Regex.IsMatch(input, pattern) Then
                Console.WriteLine(input + ": matched")
            Else
                Console.WriteLine(input + ": match failed")
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       111 111-1111: matched
'       222-2222: matched
'       222 333-444: match failed
'       (212) 111-1111: matched
'       111-AB1-1111: match failed
'       212-111-1111: matched
'       01 999-9999: match failed

Символ, не являющийся цифрой: \D

\D соответствует любому символу, не являющемуся цифрой. Он эквивалентен шаблону регулярного выражения \P{Nd}.

Если задано поведение, совместимое с ECMAScript, то параметр \D эквивалентен [^0-9]. Информацию о регулярных выражениях ECMAScript см. в подразделе "Поведение сопоставления ECMAScript" раздела Параметры регулярных выражений.

В следующем примере показан элемент языка \D. Он проверяет, включает ли строка (например, номер продукта) соответствующее сочетание десятичных и недесятичных символов. Шаблон регулярного выражения ^\D\d{1,5}\D*$ определяется, как показано в следующей таблице.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^\D\d{1,5}\D*$";
      string[] inputs = { "A1039C", "AA0001", "C18A", "Y938518" };

      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern))
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       A1039C: matched
//       AA0001: match failed
//       C18A: matched
//       Y938518: match failed

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "^\D\d{1,5}\D*$"
        Dim inputs() As String = {"A1039C", "AA0001", "C18A", "Y938518"}

        For Each input As String In inputs
            If Regex.IsMatch(input, pattern) Then
                Console.WriteLine(input + ": matched")
            Else
                Console.WriteLine(input + ": match failed")
            End If
        Next
    End Sub
End Module
' The example displays the following output:

Поддерживаемые общие категории Юникода

В Юникоде определяются общие категории, приведенные в следующей таблице. Дополнительные сведения см. в подразделах "Формат файла UCD" и "Общие значения категорий" в базе данных символов Юникода с. 5.7.1, таблица 12.

Можно определить категорию Юникода для любого отдельного символа, передав его в метод GetUnicodeCategory. В следующем примере метод GetUnicodeCategory используется для определения категории каждого элемента в массиве, содержащем выбранные латинские символы.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      char[] chars = { 'a', 'X', '8', ',', ' ', '\u0009', '!' };

      foreach (char ch in chars)
         Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()),
                           Char.GetUnicodeCategory(ch));
   }
}
// The example displays the following output:
//       'a': LowercaseLetter
//       'X': UppercaseLetter
//       '8': DecimalDigitNumber
//       ',': OtherPunctuation
//       '\ ': SpaceSeparator
//       '\t': Control
//       '!': OtherPunctuation

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim chars() As Char = {"a"c, "X"c, "8"c, ","c, " "c, ChrW(9), "!"c}

        For Each ch As Char In chars
            Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()), _
                              Char.GetUnicodeCategory(ch))
        Next
    End Sub
End Module
' The example displays the following output:
'       'a': LowercaseLetter
'       'X': UppercaseLetter
'       '8': DecimalDigitNumber
'       ',': OtherPunctuation
'       '\ ': SpaceSeparator
'       '\t': Control
'       '!': OtherPunctuation

Поддерживаемые именованные блоки

Платформа .NET предоставляет именованные блоки, перечисленные в следующей таблице. Набор поддерживаемых именованных блоков составлен на основе Юникода версии 4.0 и Perl версии 5.6. Регулярное выражение, использующее именованные блоки, см. в разделе "Категория Юникода" или блок Юникода: \p{} .

Вычитание класса символов: [базовая_группа - [исключенная_группа]]

Класс знаков определяет набор знаков. Результатом вычитания класса знаков является набор знаков, полученный в результате исключения одного класса знаков из другого класса знаков.

Выражение вычитания класса знаков имеет следующий вид:

[ base_group -[ excluded_group ]]

Квадратные скобки ([]) и дефис (-) являются обязательными. base_group представляет собой положительную или отрицательную группу символов. Компонент excluded_group — это другая положительная или отрицательная группа символов или другое выражение вычитания класса символов (то есть можно осуществлять вложение выражений вычитания класса символов).

Например, предположим, что имеется базовая группа, состоящая из диапазона знаков от "а" до "z". Чтобы задать набор знаков, состоящий из базовой группы за исключением знака "m", используйте команду [a-z-[m]]. Чтобы задать набор знаков, состоящий из базовой группы за исключением знаков "d", "j", и "p", используйте команду [a-z-[djp]]. Чтобы определить набор знаков, состоящий из базовой группы за исключением диапазона знаков от "m" до "p", используйте команду [a-z-[m-p]].

Рассмотрим вложенное выражение вычитания классов знаков [a-z-[d-w-[m-o]]]. Вычисление выражения начинается из самого внутреннего диапазона знаков. Сначала диапазон знаков от "m" до "o" вычитается из диапазона знаков от "d" до "w", в результате чего остается набор знаков от "d" до "i" и от "p" до "w". Затем этот набор вычитается из диапазона знаков от "a" до "z", вследствие чего получается набор знаков [abcmnoxyz].

При вычитании класса знаков можно использовать любой класс знаков. Чтобы определить набор символов, состоящий из всех символов Юникода от \u0000 до \uFFFF, за исключением пробела (\s), знаков препинания в общей категории (\p{P}), символов в именованном блоке IsGreek (\p{IsGreek}) и управляющего символа Юникода "следующая строка" (\x85), используйте [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].

Выберите классы знаков для выражения вычитания класса знаков, которое возвратит полезные результаты. Избегайте выражений, в результате которых возвращается пустой набор знаков, который ничему не соответствует, и выражений, эквивалентных исходной базовой группе. Например, пустой набор является результатом выражения [\p{IsBasicLatin}-[\x00-\x7F]], которое вычитает все символы диапазона IsBasicLatin из общей категории IsBasicLatin. Аналогично, результатом выражения [a-z-[0-9]] является исходная базовая группа. Это происходит из-за того, что базовая группа, которая является диапазоном букв от "a" до "z", не содержит знаков исключаемой группы, которая является диапазоном десятичных цифр от "0" до "9".

В следующем примере определяется регулярное выражение ^[0-9-[2468]]+$, которое выделяет ноль и нечетные цифры во входной строке. Возможные интерпретации регулярного выражения показаны в следующей таблице.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "123", "13579753", "3557798", "335599901" };
      string pattern = @"^[0-9-[2468]]+$";

      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern);
         if (match.Success)
            Console.WriteLine(match.Value);
      }
   }
}
// The example displays the following output:
//       13579753
//       335599901

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim inputs() As String = {"123", "13579753", "3557798", "335599901"}
        Dim pattern As String = "^[0-9-[2468]]+$"

        For Each input As String In inputs
            Dim match As Match = Regex.Match(input, pattern)
            If match.Success Then Console.WriteLine(match.Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       13579753
'       335599901

См. также

• GetUnicodeCategory
• Элементы языка регулярных выражений — краткий справочник
• Параметры регулярных выражений