Классы знаков

Статья
08/11/2011

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

Группы положительных знаков. Символ в строке ввода должен соответствовать одному из указанных наборов символов. Дополнительные сведения см. в разделе Положительная группа символов.
Группы отрицательных знаков. Символ в строке ввода не должен соответствовать одному из указанных наборов символов. Дополнительные сведения см. в разделе Отрицательная группа символов.
Любой знак. Символ . (точка) в регулярных выражениях является подстановочным знаком, с которым совпадают все символы, кроме \n. Дополнительные сведения см. в описании любого символа.
Общая категория Юникода или именованный блок. Символ в строке ввода должен быть членом определенной категории Юникода или должен попадать в непрерывный диапазон символов Юникода для успешного выполнения соответствия. Дополнительные сведения см. в разделе Категория Юникода или блок Юникода.
Отрицательная общая категория Юникода или именованный блок. Символ в строке ввода не должен быть членом определенной категории Юникода или не должен попадать в непрерывный диапазон символов Юникода для успешного выполнения соответствия. Дополнительные сведения см. в разделе Отрицательные категории Юникода или блоки Юникода.
Буквенный символ. Символ в строке ввода может принадлежать любой из категорий Юникода, которые соответствуют символам в словах. Дополнительные сведения см. в описании буквенного символа.
Символ, не являющийся буквой. Символ в строке ввода может принадлежать любой категории Юникода, не являющейся буквенным символом. Дополнительные сведения см. в описании символа, не являющегося буквой.
Символ пробела. Символ в строке ввода может быть любым разделителем Юникода, а также любым из множества управляющих символов. Дополнительные сведения см. в описании символа, являющегося пробелом.
Символ, не являющийся пробелом. Символа в строке ввода может быть любым символом, кроме пробела. Дополнительные сведения см. в описании символа, не являющегося пробелом.
Десятичная цифра Символ в строке ввода может быть любым числом знаков, классифицируемых как десятичные цифры Юникода. Дополнительные сведения см. в описании символа десятичной цифры.
Цифра, не являющаяся десятичной. Символ в строке ввода может быть любым символом, кроме десятичных цифр Юникода. Дополнительные сведения см. в описании символа десятичной цифры.

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

Группа положительных знаков: [ ]

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

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

[группа_знаков]

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

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

[firstCharacter-lastCharacter]

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

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

Шаблон	Описание
[aeiou]	Выделяет все гласные.
[\p{P}\d]	Выделяет все знаки препинания и символы десятичных цифр.
[\s\p{P}]	Выделяет символ пробела и знаки препинания.

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

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.

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.

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

Шаблон	Описание
gr	Выделить буквенные символы "gr".
[ae]	Соответствует "a" или "e".
y\s	Выделить буквенный символ "y", за которым следует символ пробела.
\S+?	Соответствует одному или минимально возможному числу символов пробела.
[\s\|\p{P}]	Совпадает с символом пробела или знаком препинания.

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

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

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

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

Шаблон	Описание
\b	Начало на границе слова.
[A-Z]	Выделяет любой символ верхнего регистра от А до Z.
\w*	Соответствует нулевому или большему числу буквенных символов.
\b	Соответствует границе слова.

К началу

Группа отрицательных знаков: [^]

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

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

[^группа_знаков]

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

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

[^первый_символ-последний_символ]

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

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

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

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

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

Шаблон	Описание
[^aeiou]	Выделяет все символы кроме гласных.
[^\p{P}\d]	Соответствует всем символам кроме знаков препинания и десятичных цифр.

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

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

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

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

Шаблон	Описание
\b	Начало на границе слова.
th	Выделить буквенные символы "th".
[^o]	Выделяет любой символ, отличающийся от "o".
\w+	Совпадение с одним или несколькими символами слова.
\b	Конец на границе слова.

К началу

Любой знак: .

Символ точки (.) соответствует любому символу, кроме \n (символ перевода строки, \u000A), с помощью следующих двух квалификаторов:

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

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

Примечание
Так как он соответствует любому символу, кроме \n, класс символов . также соответствует символу \r (символ возврата каретки, \u000D).

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

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

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

К началу

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

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

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

\p{name}

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

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

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

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

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

Шаблон	Описание
\b	Начало на границе слова.
\p{IsGreek}+	Соответствует одному или нескольким греческим символам.
(\s)?	Выделить ноль или один символ пробела.
(\p{IsGreek}+(\s)?)+	Выделить один или несколько раз шаблон из одного или нескольких греческих символов, за которыми следует ноль или один символ пробела.
\p{Pd}	Выделяет знаки препинания и тире.
\s	Соответствует пробелу.
\p{IsBasicLatin}+	Выделяет один или несколько базовых латинских символов.
(\s)?	Выделить ноль или один символ пробела.
(\p{IsBasicLatin}+(\s)?)+	Выделить один или несколько раз шаблон из одного или нескольких базовых латинских символов, за которыми следует ноль или один символ пробела.

К началу

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

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

\P{name}

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

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

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

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

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

К началу

Символ слова: \w

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

Категория	Описание
Ll	Буква: строчные буквы
Lu	Буква: прописные буквы
Lt	Буква: заглавный регистр
Lo	Буква: другие
Lm	Буква: модификатор
Nd	Число: десятичная цифра
Pc	Пунктуация, соединитель. Эта категория включает десять символов, наиболее часто используемым из которых является символ подчеркивания (_), u+005F.

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

Примечание
Так как он соответствует любому символу, являющемуся буквой, элемент языка \w часто используется с отложенным квантором, если шаблон регулярного выражения пытается несколько раз сопоставить любой символ, являющийся буквой, за которым следует конкретный буквенный символ.Дополнительные сведения см. в разделе Кванторы.

Так как он соответствует любому символу, являющемуся буквой, элемент языка \w часто используется с отложенным квантором, если шаблон регулярного выражения пытается несколько раз сопоставить любой символ, являющийся буквой, за которым следует конкретный буквенный символ.Дополнительные сведения см. в разделе Кванторы.

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

Элемент	Описание
(\w)	Выделяет буквенный символ. Это первая группа записи.
\1	Выделить значение первой записи.

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.

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.

К началу

Символ, не являющийся буквой: \W

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

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

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

Категория	Описание
Ll	Буква: строчные буквы
Lu	Буква: прописные буквы
Lt	Буква: заглавный регистр
Lo	Буква: другие
Lm	Буква: модификатор
Nd	Число: десятичная цифра
Pc	Пунктуация, соединитель. Эта категория включает десять символов, наиболее часто используемым из которых является символ подчеркивания (_), u+005F.

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

Примечание
Так как он соответствует любому символу, не являющемуся буквой, элемент языка \W часто используется с отложенным квантором, если шаблон регулярного выражения пытается несколько раз сопоставить любой символ, не являющийся буквой, за которым следует конкретный символ, не являющийся буквой.Дополнительные сведения см. в разделе Кванторы.

Так как он соответствует любому символу, не являющемуся буквой, элемент языка \W часто используется с отложенным квантором, если шаблон регулярного выражения пытается несколько раз сопоставить любой символ, не являющийся буквой, за которым следует конкретный символ, не являющийся буквой.Дополнительные сведения см. в разделе Кванторы.

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

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

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)

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)

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

К началу

Пробел: \s

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

Категория	Описание
\f	Символ перевода страницы, \u000C.
\n	Символ новой строки, \u000A.
\r	Символ возврата каретки, \u000D.
\t	Символ табуляции, \u0009.
\v	Символ вертикальной табуляции, \u000B.
\x85	Многоточие или символ NEXT LINE (NEL) (…), \u0085.
\p{Z}	Соответствует любому разделительному символу.

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

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

Элемент	Описание
\b	Совпадение должно начинаться на границе слова.
\w+	Совпадение с одним или несколькими символами слова.
(e)*	Выделяет "e" несколько раз (если они есть).
s	Выделяет "s".
(\s\|$)	Совпадает с символом пробела или концом входной строки.

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

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

К началу

Символ, не являющийся пробелом: \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 содержит совпадающую строку. Возможные интерпретации регулярного выражения показаны в следующей таблице.

Элемент	Описание
\b	Совпадение должно начинаться на границе слова.
(\S+)	Соответствует одному или нескольким символам, не являющимся пробелом. Это первая группа записи.
\s*	Выделить ноль или один символ пробела.

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.

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.

К началу

Символ десятичной цифры: \d

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

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

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

Элемент	Описание
^	Начало совпадения в начале входной строки.
\(*	Выделить ноль или один символ "(".
\d{3}	Совпадение с тремя десятичными цифрами.
\)*	Выделить ноль или один символ ")".
[\s-]	Выделяет пробел или дефис.
($\d{3}$[\s-])*	Выделяет несколько раз необязательные открывающие скобки с последующими тремя десятичными цифрами, необязательную закрывающую скобку, а также знак пробела или дефис (если они есть). Это первая группа записи.
\d{3}=\d{4}	Выделить три десятичных цифры и следующие за ними дефис и еще четыре десятичные цифры.
$	Соответствует концу входной строки.

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

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

К началу

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

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

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

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

Элемент	Описание
^	Начало совпадения в начале входной строки.
\D	Выделяет любой символ, не являющийся цифрой.
\d{1,5}	Выделяет от одной до пяти десятичных цифр.
\D*	Выделить ноль или один символ, не являющийся десятичной цифрой.
$	Соответствует концу входной строки.

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:

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

К началу

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

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

Категория	Описание
Lu	Буква: прописные буквы
Ll	Буква: строчные буквы
Lt	Буква: заглавный регистр
Lm	Буква: модификатор
Lo	Буква: другие
L	Все буквенные символы. Это относится к знакам Lu, Ll, Lt, Lm и Lo.
Mn	Метка: безразрывная
Mc	Метка: комбинированная
Me	Метка: вложенная
M	Все диакритические знаки. Это относится к категориям Mn, Mc и Me.
Nd	Число: десятичная цифра
Nl	Число: буква
No	Число: другое
N	Все числа. Это относится к категориям Nd, Nl и No.
Pc	Пунктуация: соединительные знаки пунктуации
Pd	Пунктуация: тире
Ps	Пунктуация: открывающий знак пунктуации
Pe	Пунктуация: закрывающий знак пунктуации
Pi	Пунктуация: начало цитаты (может вести себя как Ps или Pe, в зависимости от использования)
Pf	Пунктуация: конец цитаты (может вести себя как Ps или Pe, в зависимости от использования)
Po	Пунктуация: другие знаки пунктуации
P	Все знаки препинания. Это относится к категориям Pc, Pd, Ps, Pe, Pi, Pf и Po.
Sm	Символ: математический символ
Sc	Символ: символ денежной единицы
Sk	Символ: модификатор
So	Символ: другие
S	Все символы. Это относится к категориям Sm, Sc, Sk, So и .
Zs	Разделитель: пробел
Zl	Разделитель: строка
Zp	Разделитель: абзац
Z	Все знаки разделения. Это относится к категориям Zs, Zl и Zp.
Cc	Другое: управляющий символ
Cf	Другое: формат
Cs	Другое: заменяющий символ
Co	Другое: индивидуальное использование
Cn	Другое: не назначенные символы (ни один символ не имеет этого свойства)
C	Все управляющие символы. Это относится к категориям Cc, Cf, Cs, Co и Cn.

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

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

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

К началу

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

Платформа .NET Framework предоставляет именованные блоки, перечисленные в следующей таблице. Набор поддерживаемых именованных блоков составлен на основе Юникода версии 4.0 и Perl версии 5.6.

Диапазон кодовых точек	Имя блока
0000 - 007F	IsBasicLatin
0080 - 00FF	IsLatin-1Supplement
0100 - 017F	IsLatinExtended-A
0180 - 024F	IsLatinExtended-B
0250 - 02AF	IsIPAExtensions
02B0 - 02FF	IsSpacingModifierLetters
0300 - 036F	IsCombiningDiacriticalMarks
0370 - 03FF	IsGreek – или – IsGreekandCoptic
0400 - 04FF	IsCyrillic
0500 - 052F	IsCyrillicSupplement
0530 - 058F	IsArmenian
0590 - 05FF	IsHebrew
0600 - 06FF	IsArabic
0700 - 074F	IsSyriac
0780 - 07BF	IsThaana
097F - 0900	IsDevanagari
0980 - 09FF	IsBengali
0A00 - 0A7F	IsGurmukhi
0A80 - 0AFF	IsGujarati
0B00 - 0B7F	IsOriya
0B80 - 0BFF	IsTamil
0C00 - 0C7F	IsTelugu
0C80 - 0CFF	IsKannada
0D00 - 0D7F	IsMalayalam
0D80 - 0DFF	IsSinhala
0E00 - 0E7F	IsThai
0E80 - 0EFF	IsLao
0F00 - 0FFF	IsTibetan
1000 - 109F	IsMyanmar
10A0 - 10FF	IsGeorgian
1100 - 11FF	IsHangulJamo
1200 - 137F	IsEthiopic
13A0 - 13FF	IsCherokee
1400 - 167F	IsUnifiedCanadianAboriginalSyllabics
1680 - 169F	IsOgham
16A0 - 16FF	IsRunic
1700 - 171F	IsTagalog
1720 - 173F	IsHanunoo
1740 - 175F	IsBuhid
1760 - 177F	IsTagbanwa
1780 - 17FF	IsKhmer
1800 - 18AF	IsMongolian
1900 - 194F	IsLimbu
1950 - 197F	IsTaiLe
19E0 - 19FF	IsKhmerSymbols
1D00 - 1D7F	IsPhoneticExtensions
1E00 - 1EFF	IsLatinExtendedAdditional
1F00 - 1FFF	IsGreekExtended
2000 - 206F	IsGeneralPunctuation
2070 - 209F	IsSuperscriptsandSubscripts
20A0 - 20CF	IsCurrencySymbols
20D0 - 20FF	IsCombiningDiacriticalMarksforSymbols – или – IsCombiningMarksforSymbols
2100 - 214F	IsLetterlikeSymbols
2150 - 218F	IsNumberForms
2190 - 21FF	IsArrows
2200 - 22FF	IsMathematicalOperators
2300 - 23FF	IsMiscellaneousTechnical
2400 - 243F	IsControlPictures
245F - 2440	IsOpticalCharacterRecognition
2460 - 24FF	IsEnclosedAlphanumerics
257F - 2500	IsBoxDrawing
2580 - 259F	IsBlockElements
25A0 - 25FF	IsGeometricShapes
2600 - 26FF	IsMiscellaneousSymbols
2700 - 27BF	IsDingbats
27C0 - 27EF	IsMiscellaneousMathematicalSymbols-A
27F0 - 27FF	IsSupplementalArrows-A
2800 - 28FF	IsBraillePatterns
2900 - 297F	IsSupplementalArrows-B
2980 - 29FF	IsMiscellaneousMathematicalSymbols-B
2A00 - 2AFF	IsSupplementalMathematicalOperators
2B00 - 2BFF	IsMiscellaneousSymbolsandArrows
2E80 - 2EFF	IsCJKRadicalsSupplement
2F00 - 2FDF	IsKangxiRadicals
2FF0 - 2FFF	IsIdeographicDescriptionCharacters
3000 - 303F	IsCJKSymbolsandPunctuation
3040 - 309F	IsHiragana
30A0 - 30FF	IsKatakana
3100 - 312F	IsBopomofo
3130 - 318F	IsHangulCompatibilityJamo
3190 - 319F	IsKanbun
31A0 - 31BF	IsBopomofoExtended
31F0 - 31FF	IsKatakanaPhoneticExtensions
3200 - 32FF	IsEnclosedCJKLettersandMonths
3300 - 33FF	IsCJKCompatibility
3400 - 4DBF	IsCJKUnifiedIdeographsExtensionA
4DC0 - 4DFF	IsYijingHexagramSymbols
4E00 - 9FFF	IsCJKUnifiedIdeographs
A000 - A48F	IsYiSyllables
A490 - A4CF	IsYiRadicals
AC00 - D7AF	IsHangulSyllables
D800 - DB7F	IsHighSurrogates
DB80 - DBFF	IsHighPrivateUseSurrogates
DC00 - DFFF	IsLowSurrogates
E000 - F8FF	IsPrivateUse или IsPrivateUseArea
F900 - FAFF	IsCJKCompatibilityIdeographs
FB00 - FB4F	IsAlphabeticPresentationForms
FB50 - FDFF	IsArabicPresentationForms-A
FE00 - FE0F	IsVariationSelectors
FE20 - FE2F	IsCombiningHalfMarks
FE30 - FE4F	IsCJKCompatibilityForms
FE50 - FE6F	IsSmallFormVariants
FE70 - FEFF	IsArabicPresentationForms-B
FF00 - FFEF	IsHalfwidthandFullwidthForms
FFF0 - FFFF	IsSpecials

К началу

Вычитание класса знаков

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

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

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

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

Например, предположим, что имеется базовая группа, состоящая из диапазона знаков от "а" до "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}) и управляющего символа юникода NEXT LINE (\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]]+$, которое выделяет ноль и нечетные цифры во входной строке. Возможные интерпретации регулярного выражения показаны в следующей таблице.

Элемент	Описание
^	Соответствие должно обнаруживаться в начале строки ввода.
[0-9-[2468]]+	Соответствует одному или нескольким вхождениям любого символа от 0 до 9, за исключением 2, 4, 6 и 8. Другими словами, соответствует одно или несколько вхождений нуля или нечетной цифры.
$	Соответствие должно заканчиваться в конце строки ввода.

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

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

К началу

См. также

Ссылки

GetUnicodeCategory

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

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

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

Поделиться через

Классы знаков

Группа положительных знаков: [ ]

Группа отрицательных знаков: [^]

Любой знак: .

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

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

Символ слова: \w

Символ, не являющийся буквой: \W

Пробел: \s

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

Символ десятичной цифры: \d

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

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

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

Вычитание класса знаков

См. также

Ссылки

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

Дополнительные ресурсы