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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечание.

Классы символов, которые сопоставляют символы по категориям, например \w, для соответствия символов слов или \p{} для соответствия категории Юникод, используют класс CharUnicodeInfo для получения сведений о категориях символов. В .NET Framework 4.6.2 и более поздних версиях категории символов основаны на The Unicode Standard, версия 8.0.0.

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

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

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

[*character_group*]

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

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

[firstCharacter-lastCharacter]

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

Примечание.

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

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

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

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

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

static void PositiveCharacterGroup()
{
    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.'

Sub PositiveCharacterGroup()
    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
' 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.

static void CharacterRange()
{
    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

Sub CharacterRange()
    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
' The example displays the following output:
'       A
'       Albany
'       Zulu
'       Marseilles

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

Расписание Описание
\b Начните с границы слова.
[A-Z] Соответствует любому символу верхнего регистра от А до 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].

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

Внимание

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

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

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

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

static void NegativeCharacterGroup()
{
    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

Sub NegativeCharacterGroup()
    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
' The example displays the following output:
'       thing
'       them
'       through
'       thus
'       this

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

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

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

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

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

  • Начиная с .NET 11, если указан параметр RegexOptions.AnyNewLine, . исключает все общие последовательности новой линии вместо \n. Если заданы оба Singleline и AnyNewLine, Singleline имеет приоритет, а . соответствует каждому символу. Дополнительные сведения см. в режиме AnyNewLine.

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

    static void AnyCharacterMultiline()
{
    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\.

    Sub AnyCharacterMultiline()
    Dim pattern As String = "^.+"
    Dim input As String = "This is one line and" + Environment.NewLine + "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
' The example displays the following output:
'       This\ is\ one\ line\ and\r
'
'       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

Примечание.

По умолчанию, поскольку класс символов \n соответствует любому символу, кроме ., он также соответствует \r (символ возврата каретки). RegexOptions.AnyNewLine, . исключает \r и другие последовательности новой строки.

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

    static void AnyCharacterSingleline()
{
    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.

    Sub AnyCharacterSingleline()
    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
' The example displays the following output:
'       this. what: is? go, thing.

Примечание.

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

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

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

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

\p{ имя}

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

Совет

Сопоставление можно улучшить, если строка сначала нормализуется путем вызова String.Normalize метода.

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

static void UnicodeCategory()
{
    string pattern = @"\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+";
    string input = "Ελληνική Γλώσσα - Greek Language";

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

Sub UnicodeCategory()
    Dim pattern As String = "\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+"
    Dim input As String = "Ελληνική Γλώσσα - Greek Language"

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

Определение регулярного выражения \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{}

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

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

\P{ имя}

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

Совет

Сопоставление можно улучшить, если строка сначала нормализуется путем вызова String.Normalize метода.

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

static void NegativeUnicodeCategory()
{
    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

Sub NegativeUnicodeCategory()
    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
' The example displays the following output:
'       164,091.78
'       1,073,142.68
'       73
'       120

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

символ Word: \w

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

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

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

Примечание.

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

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

Элемент Описание
(\w) Соответствует словообразующему символу. Это первая группа записи.
\1 Соответствует значению первой записи. 
static void WordCharacter()
{
    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($"'{match.Value}' found in '{word}' at position {match.Index}.");
        else
            Console.WriteLine($"No double characters in '{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.

Sub WordCharacter()
    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($"'{match.Value}' found in '{word}' at position {match.Index}.")
        Else
            Console.WriteLine($"No double characters in '{word}'.")
        End If
    Next
End Sub
' 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{Lm}\p{Mn}\p{Nd}\p{Pc}]

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

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

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

Примечание.

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

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

Элемент Описание
\b Совпадение должно начинаться на границе слова.
(\w+) Совпадение с одним или несколькими символами слова. Это первая группа записи.
(\W){1,2} Совпадение небуквенного символа один или два раза. Это вторая группа захвата. 
static void NonWordCharacter()
{
    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)

Sub NonWordCharacter()
    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
' 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 соответствует любому символу пробела. Это эквивалентно escape-последовательности и категориям Юникода, перечисленным в следующей таблице.

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

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

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

Элемент Описание
\b Совпадение должно начинаться на границе слова.
\w+ Совпадение с одним или несколькими символами слова.
(e)? Совпадение с символом "e" ноль или один раз.
s Совпадает с 's'.
(\s|$) Совпадает с символом пробела или концом входной строки. 
static void WhitespaceCharacter()
{
    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

Sub WhitespaceCharacter()
    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
' 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? Совпадение с нулем или одним символом пробела. 
static void NonWhitespaceCharacter()
{
    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.

Sub NonWhitespaceCharacter()
    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." + Environment.NewLine +
                          "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
' 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} Совпадение трех десятичных цифр, за которыми следует дефис и еще четыре десятичных цифры.
$ Соответствует концу входной строки. 
static void DigitCharacter()
{
    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

Sub DigitCharacter()
    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
' 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* Совпадает с нулем, одним или несколькими не десятичными символами.
$ Соответствует концу входной строки. 
static void NonDigitCharacter()
{
    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

Sub NonDigitCharacter()
    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
' The example displays the following output:
'       A1039C: matched
'       AA0001: match failed
'       C18A: matched
'       Y938518: match failed

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

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

Категория Описание
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 используется для определения категории каждого элемента в массиве, содержащем выбранные латинские символы.

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

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

Sub GetUnicodeCategory()
    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
' The example displays the following output:
'       'a': LowercaseLetter
'       'X': UppercaseLetter
'       '8': DecimalDigitNumber
'       ',': OtherPunctuation
'       '\ ': SpaceSeparator
'       '\t': Control
'       '!': OtherPunctuation

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

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

Диапазон кодовых точек Имя блока
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
0900 - 097F 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
2440 – 245F IsOpticalCharacterRecognition
2460 - 24FF IsEnclosedAlphanumerics
2500 – 257F 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

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

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

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

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

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

Элемент Описание
^ Начать поиск совпадения с начала входной строки.
[0-9-[2468]]+ Соответствует одному или нескольким вхождениям любого символа от 0 до 9, за исключением 2, 4, 6 и 8. Другими словами, совпадают одно или несколько вхождений нуля или нечетной цифры.
$ Совпадение должно заканчиваться в конце входной строки. 
static void CharacterClassSubtraction()
{
    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

Sub CharacterClassSubtraction()
    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
' The example displays the following output:
'       13579753
'       335599901

См. также

  • Last updated on