Classes de caracteres em expressões regulares
Uma classe de caracteres define um conjunto de caracteres, qualquer dos quais pode ocorrer em uma cadeia de caracteres de entrada para que uma correspondência seja bem-sucedida. A linguagem de expressões regulares no .NET dá suporte às seguintes classes de caracteres:
Grupos de caracteres positivos. Um caractere na cadeia de caracteres de entrada deve corresponder a um de um conjunto especificado de caracteres. Para obter mais informações, consulte Positive Character Group (Grupo de caracteres positivos).
Grupo de caracteres negativos. Um caractere na cadeia de caracteres de entrada não deve corresponder a um de um conjunto especificado de caracteres. Para obter mais informações, consulte Negative Character Group (Grupo de caracteres negativos).
Qualquer caractere. O
.(ponto) em uma expressão regular é um caractere curinga que corresponde a qualquer caractere, exceto\n. Para obter mais informações, consulte Qualquer caractere.Uma categoria geral de Unicode ou bloco nomeado. Um caractere na cadeia de caracteres de entrada deve ser um membro de uma categoria de Unicode específica ou deve estar dentro de um intervalo contíguo de caracteres Unicode para que uma correspondência seja bem-sucedida. Para obter mais informações, consulte Unicode Category or Unicode Block (Bloco de Unicode ou Categoria de Unicode).
Uma categoria geral de Unicode ou bloco nomeado negativos. Um caractere na cadeia de caracteres de entrada não deve ser um membro de uma categoria de Unicode específica ou não deve estar dentro de um intervalo contíguo de caracteres Unicode para que uma correspondência seja bem-sucedida. Para obter mais informações, consulte Negative Unicode Category or Unicode Block (Categoria Unicode Negativa ou bloco Unicode).
Um caractere de palavra. Um caractere na cadeia de caracteres de entrada pode pertencer a qualquer uma das categorias Unicode que são apropriados para caracteres usados em palavras. Para obter mais informações, consulte Word Character (Caractere de palavra).
Um caractere não pertencente a palavras. Um caractere na cadeia de caracteres de entrada pode pertencer a qualquer categoria Unicode que não seja um caractere de palavra. Para obter mais informações, consulte Non-Word Character (Caractere não pertencente a palavras).
Um caractere de espaço em branco. Um caractere na cadeia de caracteres de entrada pode ser qualquer caractere separador Unicode, bem como qualquer um entre vários caracteres de controle. Para obter mais informações, consulte White-Space Character (Caractere de espaço em branco).
Um caractere diferente de espaço em branco. Um caractere na cadeia de caracteres de entrada pode ser qualquer caractere que não seja um caractere de espaço em branco. Para obter mais informações, consulte Non-White-Space Character (Caractere diferente de espaço em branco).
Um dígito decimal. Um caractere na cadeia de caracteres de entrada pode ser qualquer um entre vários caracteres classificados como dígitos decimais Unicode. Para obter mais informações, consulte Decimal Digit Character (Caractere de dígito decimal).
Um dígito não decimal. Um caractere na cadeia de caracteres de entrada pode ser qualquer coisa que não seja um dígito decimal Unicode. Para obter mais informações, consulte Decimal Digit Character (Caractere de dígito decimal).
O .NET dá suporte a expressões de subtração de classes de caracteres, o que permite a você definir um conjunto de caracteres como resultado da exclusão de uma classe de caracteres de outra classe de caracteres. Para obter mais informações, consulte Subtração de classe de caracteres.
Observação
Classes de caractere que fazem a correspondência de caracteres por categoria, como \w para a correspondência de caracteres de palavra ou \p{} para uma categoria de Unicode, dependem da classe CharUnicodeInfo para fornecer informações sobre categorias de caractere. No .NET Framework 4.6.2 e em versões posteriores, as categorias de caracteres se baseiam no Padrão Unicode, versão 8.0.0.
Grupo de caracteres positivo: [ ]
Um grupo de caracteres positivos especifica uma lista de caracteres, qualquer caractere dela pode aparecer em uma cadeia de caracteres de entrada para que uma correspondência ocorra. Essa lista de caracteres pode ser especificada individualmente, como um intervalo ou ambos.
A sintaxe para especificar uma lista de caracteres individuais é a seguinte:
[*character_group*]
em que character_group é uma lista dos caracteres individuais que podem aparecer na cadeia de caracteres de entrada para que uma correspondência seja bem-sucedida. character_group pode ser composto por qualquer combinação de um ou mais caracteres literais, caracteres de escape ou classes de caracteres.
A sintaxe para especificar um intervalo de caracteres é a seguinte:
[firstCharacter-lastCharacter]
em que firstCharacter é o caractere que inicia o intervalo e lastCharacter é o caractere que encerra o intervalo. Um intervalo de caracteres é uma série contígua de caracteres definida pela especificação do primeiro caractere na série, um hífen (-) e o último caractere na série. Dois caracteres são contíguos se eles têm pontos de código Unicode adjacentes. firstCharacter precisa ser o caractere com o ponto de código menor, enquanto lastCharacter precisa ser o caractere com o ponto de código maior.
Observação
Visto que um grupo de caracteres positivos pode incluir um conjunto de caracteres e um intervalo de caracteres, um caractere de hífen (-) é sempre interpretado como o separador de intervalo, a menos que ele seja o primeiro ou último caractere do grupo.
Para incluir um hífen como um membro não periférico de um grupo de caracteres, escape-o. Por exemplo, para criar um grupo de caracteres para o caractere a e os caracteres de - a /, a sintaxe correta é [a\--/].
Alguns padrões de expressões regulares comuns que contêm classes de caracteres positivos são listados na tabela a seguir.
| Padrão | Descrição |
|---|---|
[aeiou] |
Corresponder a todas as vogais. |
[\p{P}\d] |
Corresponder a todos os caracteres de pontuação e dígitos decimais. |
[\s\p{P}] |
Corresponder a todos os espaços em branco e à pontuação. |
O exemplo a seguir define um grupo de caracteres positivos que contém os caracteres “a” e “e” para que a cadeia de caracteres de entrada contenha as palavras “grey” ou “gray” seguida de outra palavra para que uma correspondência ocorra.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"gr[ae]y\s\S+?[\s\p{P}]";
string input = "The gray wolf jumped over the grey wall.";
MatchCollection matches = Regex.Matches(input, pattern);
foreach (Match match in matches)
Console.WriteLine($"'{match.Value}'");
}
}
// The example displays the following output:
// 'gray wolf '
// 'grey wall.'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "gr[ae]y\s\S+?[\s\p{P}]"
Dim input As String = "The gray wolf jumped over the grey wall."
Dim matches As MatchCollection = Regex.Matches(input, pattern)
For Each match As Match In matches
Console.WriteLine($"'{match.Value}'")
Next
End Sub
End Module
' The example displays the following output:
' 'gray wolf '
' 'grey wall.'
A expressão regular gr[ae]y\s\S+?[\s|\p{P}] é definida da seguinte forma:
| Padrão | Descrição |
|---|---|
gr |
Corresponder aos caracteres literais “gr”. |
[ae] |
Corresponder a um "a" ou "e". |
y\s |
Corresponder ao caractere literal “y” seguido por um caractere de espaço em branco. |
\S+? |
Corresponder a um ou mais caracteres diferentes de espaço em branco, mas o mínimo possível. |
[\s\p{P}] |
Corresponder a um caractere de espaço em branco ou a um sinal de pontuação. |
O exemplo a seguir corresponde a palavras que começam com qualquer letra maiúscula. Ele usa a subexpressão [A-Z] para representar o intervalo de letras maiúsculas de A a Z.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b[A-Z]\w*\b";
string input = "A city Albany Zulu maritime Marseilles";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Value);
}
}
// The example displays the following output:
// A
// Albany
// Zulu
// Marseilles
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b[A-Z]\w*\b"
Dim input As String = "A city Albany Zulu maritime Marseilles"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Value)
Next
End Sub
End Module
A expressão regular \b[A-Z]\w*\b é definida conforme mostrado na tabela a seguir.
| Padrão | Descrição |
|---|---|
\b |
Iniciar em um limite de palavra. |
[A-Z] |
Corresponder a qualquer caractere maiúsculo de A a Z. |
\w* |
Corresponder a zero ou mais caracteres de palavra. |
\b |
Corresponder a um limite de palavra. |
Grupo de caracteres negativos: [^]
Um grupo de caracteres negativos especifica uma lista de caracteres que não devem aparecer em uma cadeia de caracteres de entrada para que uma correspondência ocorra. A lista de caracteres pode ser especificada individualmente, como um intervalo ou ambos.
A sintaxe para especificar uma lista de caracteres individuais é a seguinte:
[*^character_group*]
em que character_group é uma lista dos caracteres individuais que não podem aparecer na cadeia de caracteres de entrada para que uma correspondência seja bem-sucedida. character_group pode ser composto por qualquer combinação de um ou mais caracteres literais, caracteres de escape ou classes de caracteres.
A sintaxe para especificar um intervalo de caracteres é a seguinte:
[^*firstCharacter*-*lastCharacter*]
em que firstCharacter é o caractere que inicia o intervalo e lastCharacter é o caractere que encerra o intervalo. Um intervalo de caracteres é uma série contígua de caracteres definida pela especificação do primeiro caractere na série, um hífen (-) e o último caractere na série. Dois caracteres são contíguos se eles têm pontos de código Unicode adjacentes. firstCharacter precisa ser o caractere com o ponto de código menor, enquanto lastCharacter precisa ser o caractere com o ponto de código maior.
Observação
Visto que um grupo de caracteres negativos pode incluir um conjunto de caracteres e um intervalo de caracteres, um caractere de hífen (-) é sempre interpretado como o separador de intervalo, a menos que ele seja o primeiro ou último caractere do grupo.
Dois ou mais intervalos de caracteres podem ser concatenados. Por exemplo, para especificar o intervalo de dígitos decimais de "0 " a "9", o intervalo de letras minúsculas de "a" a "f" e o intervalo de letras maiúsculas "A" a "F", use [0-9a-fA-F].
O caractere de circunflexo à esquerda (^) em um grupo de caracteres negativos é obrigatório e indica que o grupo de caracteres é um grupo de caracteres negativos, e não um grupo de caracteres positivos.
Importante
Um grupo de caracteres negativos em uma expressão regular maior não é uma asserção de largura zero. Ou seja, depois de avaliar o grupo de caracteres negativos, o mecanismo de expressões regulares avança um caractere na cadeia de caracteres de entrada.
Alguns padrões de expressões regulares comuns que contêm grupos de caracteres negativos são listados na tabela a seguir.
| Padrão | Descrição |
|---|---|
[^aeiou] |
Corresponder a todos os caracteres, exceto vogais. |
[^\p{P}\d] |
Corresponder a todos os caracteres, exceto de pontuação e dígitos decimais. |
O exemplo a seguir corresponde a todas as palavras que começam com os caracteres “th” e não são seguidas por um “o”.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\bth[^o]\w+\b";
string input = "thought thing though them through thus thorough this";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Value);
}
}
// The example displays the following output:
// thing
// them
// through
// thus
// this
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\bth[^o]\w+\b"
Dim input As String = "thought thing though them through thus " + _
"thorough this"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Value)
Next
End Sub
End Module
' The example displays the following output:
' thing
' them
' through
' thus
' this
A expressão regular \bth[^o]\w+\b é definida conforme mostrado na tabela a seguir.
| Padrão | Descrição |
|---|---|
\b |
Iniciar em um limite de palavra. |
th |
Corresponder aos caracteres literais “th”. |
[^o] |
Corresponder a qualquer caractere que não seja um “o”. |
\w+ |
Fazer a correspondência a um ou mais caracteres de palavra. |
\b |
Terminar em um limite de palavra. |
Qualquer caractere: .
O caractere de ponto (.) corresponde a qualquer caractere, exceto \n (o caractere de nova linha), com estas duas qualificações:
Se um padrão de expressão regular é modificado pela opção RegexOptions.Singleline, ou se a parte do padrão que contém a classe de caracteres
.é modificada pela opçãos,.corresponde a qualquer caractere. Para obter mais informações, consulte Opções de expressões regulares.O exemplo a seguir ilustra o comportamento diferente da classe de caracteres
.por padrão e com a opção RegexOptions.Singleline. A expressão regular^.+começa no início da cadeia de caracteres e corresponde a todos os caracteres. Por padrão, a correspondência termina no final da primeira linha; o padrão de expressão regular corresponde ao caractere de retorno de carro,\r, mas não corresponde a\n. Como a opção RegexOptions.Singleline interpreta toda a cadeia de caracteres de entrada como uma única linha, ela corresponde a cada caractere na cadeia de caracteres de entrada, incluindo\n.using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = "^.+"; string input = "This is one line and" + Environment.NewLine + "this is the second."; foreach (Match match in Regex.Matches(input, pattern)) Console.WriteLine(Regex.Escape(match.Value)); Console.WriteLine(); foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline)) Console.WriteLine(Regex.Escape(match.Value)); } } // The example displays the following output: // This\ is\ one\ line\ and\r // // This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.Imports System.Text.RegularExpressions Module Example Public Sub Main() Dim pattern As String = "^.+" Dim input As String = "This is one line and" + vbCrLf + "this is the second." For Each match As Match In Regex.Matches(input, pattern) Console.WriteLine(Regex.Escape(match.Value)) Next Console.WriteLine() For Each match As Match In Regex.Matches(input, pattern, RegexOptions.SingleLine) Console.WriteLine(Regex.Escape(match.Value)) Next End Sub End Module ' The example displays the following output: ' This\ is\ one\ line\ and\r ' ' This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
Observação
Como ela corresponde a qualquer caractere, exceto \n, a classe de caracteres . também corresponde a \r (o caractere de retorno de carro).
Em um grupo de caracteres positivos ou negativos, um ponto é tratado como um caractere de ponto literal e não como uma classe de caracteres. Para saber mais, confira Grupo de caracteres positivos e Grupo de caracteres negativos anteriormente neste tópico. O exemplo a seguir fornece uma ilustração ao definir uma expressão regular que inclui o caractere de ponto (
.) como uma classe de caracteres e como um membro de um grupo de caracteres positivos. A expressão regular\b.*[.?!;:](\s|\z)começa em um limite de palavra, corresponde a qualquer caractere até encontrar um de cinco sinais de pontuação, incluindo um ponto, e corresponde a um caractere de espaço em branco ou ao final da cadeia de caracteres.using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = @"\b.*[.?!;:](\s|\z)"; string input = "this. what: is? go, thing."; foreach (Match match in Regex.Matches(input, pattern)) Console.WriteLine(match.Value); } } // The example displays the following output: // this. what: is? go, thing.Imports System.Text.RegularExpressions Module Example Public Sub Main() Dim pattern As STring = "\b.*[.?!;:](\s|\z)" Dim input As String = "this. what: is? go, thing." For Each match As Match In Regex.Matches(input, pattern) Console.WriteLine(match.Value) Next End Sub End Module ' The example displays the following output: ' this. what: is? go, thing.
Observação
Como ele corresponde a qualquer caractere, o elemento de linguagem . é frequentemente usado com um quantificador lento se um padrão de expressão regular tenta corresponder a qualquer caractere várias vezes. Para saber mais, confira Quantificadores.
Categoria de Unicode ou bloco Unicode: \p{}
O padrão Unicode atribui a cada caractere uma categoria geral. Por exemplo, um caractere específico pode ser uma letra maiúscula (representada pela categoria Lu), um dígito decimal (a categoria Nd), um símbolo matemático (a categoria Sm) ou um separador de parágrafo (a categoria Zl). Os conjuntos de caracteres específicos no padrão Unicode também ocupam um intervalo específico ou um bloco de pontos de código consecutivos. Por exemplo, o conjunto de caracteres latinos básico é de \u0000 a \u007F, enquanto que o conjunto de caracteres árabe vai de \u0600 a \u06FF.
A constructo da expressão regular
\p{ nome }
corresponde a qualquer caractere que pertence a uma categoria geral de Unicode ou a um bloco nomeado, em que name é a abreviação da categoria ou o nome do bloco nomeado. Para obter uma lista de abreviações de categoria, consulte a seção Categorias gerais Unicode com suporte posteriormente neste tópico. Para obter uma lista dos blocos nomeados, consulte a seção Blocos nomeados com suporte posteriormente neste tópico.
Dica
A correspondência poderá ser melhorada se a cadeia de caracteres for normalizada pela primeira vez chamando o método String.Normalize.
O exemplo a seguir usa o constructo \p{name} para corresponder a uma categoria de Unicode geral (nesse caso, a categoria Pd ou Pontuação, Traço) e a um bloco nomeado (os blocos nomeados IsGreek e IsBasicLatin).
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+";
string input = "Κατα Μαθθαίον - The Gospel of Matthew";
Console.WriteLine(Regex.IsMatch(input, pattern)); // Displays True.
}
}
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+"
Dim input As String = "Κατα Μαθθαίον - The Gospel of Matthew"
Console.WriteLine(Regex.IsMatch(input, pattern)) ' Displays True.
End Sub
End Module
A expressão regular \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ é definida conforme mostrado na tabela a seguir.
| Padrão | Descrição |
|---|---|
\b |
Iniciar em um limite de palavra. |
\p{IsGreek}+ |
Corresponder a um ou mais caracteres gregos. |
(\s)? |
Corresponder a zero ou a um caractere de espaço em branco. |
(\p{IsGreek}+(\s)?)+ |
Corresponder ao padrão de um ou mais caracteres gregos seguidos por zero ou um caractere de espaço em branco uma ou mais vezes. |
\p{Pd} |
Corresponder a um caractere de pontuação, traço. |
\s |
Corresponde a um caractere de espaço em branco. |
\p{IsBasicLatin}+ |
Corresponder a um ou mais caracteres latinos. |
(\s)? |
Corresponder a zero ou a um caractere de espaço em branco. |
(\p{IsBasicLatin}+(\s)?)+ |
Corresponder ao padrão de um ou mais caracteres latinos básicos seguidos por zero ou um caractere de espaço em branco uma ou mais vezes. |
Categoria Unicode negativa ou bloco Unicode: \P{}
O padrão Unicode atribui a cada caractere uma categoria geral. Por exemplo, um caractere específico pode ser uma letra maiúscula (representada pela categoria Lu), um dígito decimal (a categoria Nd), um símbolo matemático (a categoria Sm) ou um separador de parágrafo (a categoria Zl). Os conjuntos de caracteres específicos no padrão Unicode também ocupam um intervalo específico ou um bloco de pontos de código consecutivos. Por exemplo, o conjunto de caracteres latinos básico é de \u0000 a \u007F, enquanto que o conjunto de caracteres árabe vai de \u0600 a \u06FF.
A constructo da expressão regular
\P{ nome }
corresponde a qualquer caractere que não pertença a uma categoria geral de Unicode ou a um bloco nomeado, em que name é a abreviação da categoria ou o nome do bloco nomeado. Para obter uma lista de abreviações de categoria, consulte a seção Categorias gerais Unicode com suporte posteriormente neste tópico. Para obter uma lista dos blocos nomeados, consulte a seção Blocos nomeados com suporte posteriormente neste tópico.
Dica
A correspondência poderá ser melhorada se a cadeia de caracteres for normalizada pela primeira vez chamando o método String.Normalize.
O exemplo a seguir usa o constructo \P{name} para remover quaisquer símbolos de moeda (nesse caso, categoria Sc, ou Símbolo, Moeda) de cadeias de caracteres numéricas.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"(\P{Sc})+";
string[] values = { "$164,091.78", "£1,073,142.68", "73¢", "€120" };
foreach (string value in values)
Console.WriteLine(Regex.Match(value, pattern).Value);
}
}
// The example displays the following output:
// 164,091.78
// 1,073,142.68
// 73
// 120
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "(\P{Sc})+"
Dim values() As String = {"$164,091.78", "£1,073,142.68", "73¢", "€120"}
For Each value As String In values
Console.WriteLine(Regex.Match(value, pattern).Value)
Next
End Sub
End Module
' The example displays the following output:
' 164,091.78
' 1,073,142.68
' 73
' 120
O padrão de expressão regular (\P{Sc})+ corresponde a um ou mais caracteres que não são símbolos de moeda; ele remove efetivamente qualquer símbolo de moeda da cadeia de caracteres de resultado.
Caractere de palavra: \w
\w corresponde a qualquer caractere de palavra. Um caractere de palavra é um membro de qualquer uma das categorias Unicode listadas na tabela a seguir.
| Categoria | Descrição |
|---|---|
| Ll | Letra, minúscula |
| Lu | Letra, maiúscula |
| Lt | Letra, título |
| Lo | Letra, outra |
| Lm | Letra, modificador |
| Mn | Marca, sem espaçamento |
| Nd | Número, dígito decimal |
| Pc | Pontuação, conector. Essa categoria inclui dez caracteres, o mais comumente usado deles é o LOWLINE (_), u+005F. |
Se o comportamento compatível com ECMAScript for especificado, \w será equivalente a [a-zA-Z_0-9]. Para obter informações sobre expressões regulares ECMAScript, consulte a seção “Comportamento de correspondência ECMAScript" em Opções de expressões regulares.
Observação
Como ele corresponde a qualquer caractere de palavra, o elemento de linguagem \w é frequentemente usado com um quantificador lento se um padrão de expressão regular tenta corresponder a qualquer caractere de palavra várias vezes, seguido por um caractere de palavra específico. Para saber mais, confira Quantificadores.
O exemplo a seguir usa o elemento de linguagem \w para corresponder a caracteres duplicados em uma palavra. O exemplo define um padrão de expressão regular, (\w)\1, que pode ser interpretado como a seguir.
| Elemento | Descrição |
|---|---|
| (\w) | Corresponder a um caractere de palavra. Este é o primeiro grupo de captura. |
| \1 | Corresponder ao valor da primeira captura. |
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"(\w)\1";
string[] words = { "trellis", "seer", "latter", "summer",
"hoarse", "lesser", "aardvark", "stunned" };
foreach (string word in words)
{
Match match = Regex.Match(word, pattern);
if (match.Success)
Console.WriteLine("'{0}' found in '{1}' at position {2}.",
match.Value, word, match.Index);
else
Console.WriteLine("No double characters in '{0}'.", word);
}
}
}
// The example displays the following output:
// 'll' found in 'trellis' at position 3.
// 'ee' found in 'seer' at position 1.
// 'tt' found in 'latter' at position 2.
// 'mm' found in 'summer' at position 2.
// No double characters in 'hoarse'.
// 'ss' found in 'lesser' at position 2.
// 'aa' found in 'aardvark' at position 0.
// 'nn' found in 'stunned' at position 3.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "(\w)\1"
Dim words() As String = {"trellis", "seer", "latter", "summer", _
"hoarse", "lesser", "aardvark", "stunned"}
For Each word As String In words
Dim match As Match = Regex.Match(word, pattern)
If match.Success Then
Console.WriteLine("'{0}' found in '{1}' at position {2}.", _
match.Value, word, match.Index)
Else
Console.WriteLine("No double characters in '{0}'.", word)
End If
Next
End Sub
End Module
' The example displays the following output:
' 'll' found in 'trellis' at position 3.
' 'ee' found in 'seer' at position 1.
' 'tt' found in 'latter' at position 2.
' 'mm' found in 'summer' at position 2.
' No double characters in 'hoarse'.
' 'ss' found in 'lesser' at position 2.
' 'aa' found in 'aardvark' at position 0.
' 'nn' found in 'stunned' at position 3.
Caractere não pertencente a palavras: \W
\W corresponde a qualquer caractere que não seja uma palavra. O elemento de linguagem \W é equivalente à seguinte classe de caracteres:
[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]
Em outras palavras, ele corresponde a qualquer caractere, com exceção dos listados nas categorias de Unicode na tabela a seguir.
| Categoria | Descrição |
|---|---|
| Ll | Letra, minúscula |
| Lu | Letra, maiúscula |
| Lt | Letra, título |
| Lo | Letra, outra |
| Lm | Letra, modificador |
| Mn | Marca, sem espaçamento |
| Nd | Número, dígito decimal |
| Pc | Pontuação, conector. Essa categoria inclui dez caracteres, o mais comumente usado deles é o LOWLINE (_), u+005F. |
Se o comportamento compatível com ECMAScript for especificado, \W será equivalente a [^a-zA-Z_0-9]. Para obter informações sobre expressões regulares ECMAScript, consulte a seção “Comportamento de correspondência ECMAScript" em Opções de expressões regulares.
Observação
Como ele corresponde a qualquer caractere não pertencente a palavras, o elemento de linguagem \W é frequentemente usado com um quantificador lento se um padrão de expressão regular tenta corresponder a qualquer caractere não pertencente a palavras várias vezes, seguido por um caractere não pertencente a palavras específico. Para saber mais, confira Quantificadores.
O exemplo a seguir ilustra a classe de caracteres \W. Ele define um padrão de expressão regular, \b(\w+)(\W){1,2}, que corresponde a uma palavra seguida por um ou dois caracteres não pertencentes a palavras, como espaço em branco ou pontuação. A expressão regular é interpretada conforme mostrado na tabela a seguir.
| Elemento | Descrição |
|---|---|
| \b | Começar a correspondência em um limite de palavra. |
| (\w+) | Fazer a correspondência a um ou mais caracteres de palavra. Este é o primeiro grupo de captura. |
| (\W){1,2} | Corresponde a um caractere não pertencente a palavras uma ou duas vezes. Este é o segundo grupo de captura. |
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b(\w+)(\W){1,2}";
string input = "The old, grey mare slowly walked across the narrow, green pasture.";
foreach (Match match in Regex.Matches(input, pattern))
{
Console.WriteLine(match.Value);
Console.Write(" Non-word character(s):");
CaptureCollection captures = match.Groups[2].Captures;
for (int ctr = 0; ctr < captures.Count; ctr++)
Console.Write(@"'{0}' (\u{1}){2}", captures[ctr].Value,
Convert.ToUInt16(captures[ctr].Value[0]).ToString("X4"),
ctr < captures.Count - 1 ? ", " : "");
Console.WriteLine();
}
}
}
// The example displays the following output:
// The
// Non-word character(s):' ' (\u0020)
// old,
// Non-word character(s):',' (\u002C), ' ' (\u0020)
// grey
// Non-word character(s):' ' (\u0020)
// mare
// Non-word character(s):' ' (\u0020)
// slowly
// Non-word character(s):' ' (\u0020)
// walked
// Non-word character(s):' ' (\u0020)
// across
// Non-word character(s):' ' (\u0020)
// the
// Non-word character(s):' ' (\u0020)
// narrow,
// Non-word character(s):',' (\u002C), ' ' (\u0020)
// green
// Non-word character(s):' ' (\u0020)
// pasture.
// Non-word character(s):'.' (\u002E)
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b(\w+)(\W){1,2}"
Dim input As String = "The old, grey mare slowly walked across the narrow, green pasture."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Value)
Console.Write(" Non-word character(s):")
Dim captures As CaptureCollection = match.Groups(2).Captures
For ctr As Integer = 0 To captures.Count - 1
Console.Write("'{0}' (\u{1}){2}", captures(ctr).Value, _
Convert.ToUInt16(captures(ctr).Value.Chars(0)).ToString("X4"), _
If(ctr < captures.Count - 1, ", ", ""))
Next
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output:
' The
' Non-word character(s):' ' (\u0020)
' old,
' Non-word character(s):',' (\u002C), ' ' (\u0020)
' grey
' Non-word character(s):' ' (\u0020)
' mare
' Non-word character(s):' ' (\u0020)
' slowly
' Non-word character(s):' ' (\u0020)
' walked
' Non-word character(s):' ' (\u0020)
' across
' Non-word character(s):' ' (\u0020)
' the
' Non-word character(s):' ' (\u0020)
' narrow,
' Non-word character(s):',' (\u002C), ' ' (\u0020)
' green
' Non-word character(s):' ' (\u0020)
' pasture.
' Non-word character(s):'.' (\u002E)
Como o objeto Group do segundo grupo de captura contém apenas um único caractere capturado não pertencente a palavras, o exemplo recupera todos os caracteres capturados não pertencentes a palavras do objeto CaptureCollection retornado pela propriedade Group.Captures.
Caractere de espaço em branco: \s
\s corresponde a um caractere de espaço em branco. É equivalente às sequências de escape e às categorias de Unicode listadas na tabela a seguir.
| Categoria | Descrição |
|---|---|
\f |
O caractere de avanço de página, \u000C. |
\n |
O caractere de nova linha, \u000A. |
\r |
O caractere de retorno de carro, \u000D. |
\t |
O caractere de tabulação, \u0009. |
\v |
O caractere de tabulação vertical, \u000B. |
\x85 |
O caractere NEXT LINE (NEL), \u0085. |
\p{Z} |
Corresponde a todos os caracteres separadores. Isso inclui as categorias Zs, Zl e Zp. |
Se o comportamento compatível com ECMAScript for especificado, \s será equivalente a [ \f\n\r\t\v]. Para obter informações sobre expressões regulares ECMAScript, consulte a seção “Comportamento de correspondência ECMAScript" em Opções de expressões regulares.
O exemplo a seguir ilustra a classe de caracteres \s. Ele define um padrão de expressão regular, \b\w+(e)?s(\s|$), que corresponde a uma palavra que termina em “s” ou em “es” seguida por um caractere de espaço em branco ou pelo final da cadeia de caracteres de entrada. A expressão regular é interpretada conforme mostrado na tabela a seguir.
| Elemento | Descrição |
|---|---|
| \b | Começar a correspondência em um limite de palavra. |
| \w+ | Fazer a correspondência a um ou mais caracteres de palavra. |
| (e)? | Corresponder a um “e” zero ou uma vez. |
| s | Corresponder a um “s”. |
| (\s|$) | Corresponder a um caractere de espaço em branco ou ao fim da cadeia de caracteres de entrada. |
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b\w+(e)?s(\s|$)";
string input = "matches stores stops leave leaves";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Value);
}
}
// The example displays the following output:
// matches
// stores
// stops
// leaves
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b\w+(e)?s(\s|$)"
Dim input As String = "matches stores stops leave leaves"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Value)
Next
End Sub
End Module
' The example displays the following output:
' matches
' stores
' stops
' leaves
Caractere diferente de espaço em branco: \S
\S corresponde a qualquer caractere que não seja um caractere de espaço em branco. Ele é equivalente ao padrão de expressão regular [^\f\n\r\t\v\x85\p{Z}] ou o oposto do padrão de expressão regular equivalente a \s, o qual corresponde a caracteres de espaço em branco. Para saber mais, confira Caractere de espaço em branco: \s.
Se o comportamento compatível com ECMAScript for especificado, \S será equivalente a [^ \f\n\r\t\v]. Para obter informações sobre expressões regulares ECMAScript, consulte a seção “Comportamento de correspondência ECMAScript" em Opções de expressões regulares.
O exemplo a seguir ilustra o elemento de linguagem \S. O padrão de expressão regular \b(\S+)\s? corresponde a cadeias de caracteres que são delimitadas por caracteres de espaço em branco. O segundo elemento no objeto GroupCollection da correspondência contém a cadeia de caracteres correspondida. A expressão regular pode ser interpretada conforme mostrado na tabela a seguir.
| Elemento | Descrição |
|---|---|
\b |
Começar a correspondência em um limite de palavra. |
(\S+) |
Corresponder a um ou mais caracteres diferentes de espaço em branco. Este é o primeiro grupo de captura. |
\s? |
Corresponder a zero ou a um caractere de espaço em branco. |
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b(\S+)\s?";
string input = "This is the first sentence of the first paragraph. " +
"This is the second sentence.\n" +
"This is the only sentence of the second paragraph.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Groups[1]);
}
}
// The example displays the following output:
// This
// is
// the
// first
// sentence
// of
// the
// first
// paragraph.
// This
// is
// the
// second
// sentence.
// This
// is
// the
// only
// sentence
// of
// the
// second
// paragraph.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b(\S+)\s?"
Dim input As String = "This is the first sentence of the first paragraph. " + _
"This is the second sentence." + vbCrLf + _
"This is the only sentence of the second paragraph."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Groups(1))
Next
End Sub
End Module
' The example displays the following output:
' This
' is
' the
' first
' sentence
' of
' the
' first
' paragraph.
' This
' is
' the
' second
' sentence.
' This
' is
' the
' only
' sentence
' of
' the
' second
' paragraph.
Caractere de dígito decimal: \d
\d corresponde a qualquer dígito decimal. É equivalente ao padrão de expressão regular \p{Nd}, o qual inclui os dígitos decimais padrão 0-9, bem como os dígitos decimais de vários outros conjuntos de caracteres.
Se o comportamento compatível com ECMAScript for especificado, \d será equivalente a [0-9]. Para obter informações sobre expressões regulares ECMAScript, consulte a seção “Comportamento de correspondência ECMAScript" em Opções de expressões regulares.
O exemplo a seguir ilustra o elemento de linguagem \d. Ele testa se uma cadeia de caracteres de entrada representa um número de telefone válido nos Estados Unidos e no Canadá. O padrão de expressão regular ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ é definido conforme mostrado na tabela a seguir.
| Elemento | Descrição |
|---|---|
^ |
Começar a correspondência no início da cadeia de caracteres de entrada. |
\(? |
Corresponder a zero ou a um caractere "(" literal. |
\d{3} |
Corresponder a três dígitos decimais. |
\)? |
Corresponder a zero ou a um caractere ")" literal. |
[\s-] |
Corresponder a um hífen ou a caractere de espaço em branco. |
(\(?\d{3}\)?[\s-])? |
Corresponder a um parêntese de abertura opcional seguido por três dígitos decimais, um parêntese de fechamento opcional e um caractere de espaço em branco ou um hífen zero ou uma vez. Este é o primeiro grupo de captura. |
\d{3}-\d{4} |
Corresponder aos três dígitos decimais seguidos por um hífen e mais quatro dígitos decimais. |
$ |
Corresponder ao final da cadeia de caracteres de entrada. |
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$";
string[] inputs = { "111 111-1111", "222-2222", "222 333-444",
"(212) 111-1111", "111-AB1-1111",
"212-111-1111", "01 999-9999" };
foreach (string input in inputs)
{
if (Regex.IsMatch(input, pattern))
Console.WriteLine(input + ": matched");
else
Console.WriteLine(input + ": match failed");
}
}
}
// The example displays the following output:
// 111 111-1111: matched
// 222-2222: matched
// 222 333-444: match failed
// (212) 111-1111: matched
// 111-AB1-1111: match failed
// 212-111-1111: matched
// 01 999-9999: match failed
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$"
Dim inputs() As String = {"111 111-1111", "222-2222", "222 333-444", _
"(212) 111-1111", "111-AB1-1111", _
"212-111-1111", "01 999-9999"}
For Each input As String In inputs
If Regex.IsMatch(input, pattern) Then
Console.WriteLine(input + ": matched")
Else
Console.WriteLine(input + ": match failed")
End If
Next
End Sub
End Module
' The example displays the following output:
' 111 111-1111: matched
' 222-2222: matched
' 222 333-444: match failed
' (212) 111-1111: matched
' 111-AB1-1111: match failed
' 212-111-1111: matched
' 01 999-9999: match failed
Caractere que não seja dígito: \D
\D corresponde a qualquer caractere que não seja um dígito. É equivalente ao padrão de expressão regular \P{Nd}.
Se o comportamento compatível com ECMAScript for especificado, \D será equivalente a [^0-9]. Para obter informações sobre expressões regulares ECMAScript, consulte a seção “Comportamento de correspondência ECMAScript" em Opções de expressões regulares.
O exemplo a seguir ilustra o elemento de linguagem \D. Ele testa se uma cadeia de caracteres, como um número de peça, consiste na combinação apropriada de caracteres decimais e não decimais. O padrão de expressão regular ^\D\d{1,5}\D*$ é definido conforme mostrado na tabela a seguir.
| Elemento | Descrição |
|---|---|
^ |
Começar a correspondência no início da cadeia de caracteres de entrada. |
\D |
Corresponder a um caractere que não seja um dígito. |
\d{1,5} |
Corresponder a um a cinco dígitos decimais. |
\D* |
Corresponder a zero ou a um ou mais caracteres não decimais. |
$ |
Corresponder ao final da cadeia de caracteres de entrada. |
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"^\D\d{1,5}\D*$";
string[] inputs = { "A1039C", "AA0001", "C18A", "Y938518" };
foreach (string input in inputs)
{
if (Regex.IsMatch(input, pattern))
Console.WriteLine(input + ": matched");
else
Console.WriteLine(input + ": match failed");
}
}
}
// The example displays the following output:
// A1039C: matched
// AA0001: match failed
// C18A: matched
// Y938518: match failed
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "^\D\d{1,5}\D*$"
Dim inputs() As String = {"A1039C", "AA0001", "C18A", "Y938518"}
For Each input As String In inputs
If Regex.IsMatch(input, pattern) Then
Console.WriteLine(input + ": matched")
Else
Console.WriteLine(input + ": match failed")
End If
Next
End Sub
End Module
' The example displays the following output:
Categorias gerais Unicode com suporte
O Unicode define as categorias gerais listadas na tabela a seguir. Para obter mais informações, consulte os subtópicos "Formato de arquivo UCD" e "Valores de categoria geral" no Banco de dados de caractere Unicode, Sec. 5.7.1, Tabela 12.
| Categoria | Descrição |
|---|---|
Lu |
Letra, maiúscula |
Ll |
Letra, minúscula |
Lt |
Letra, título |
Lm |
Letra, modificador |
Lo |
Letra, outra |
L |
Todos os caracteres de letras. Isso inclui os caracteres Lu, Ll, Lt, Lm e Lo. |
Mn |
Marca, sem espaçamento |
Mc |
Marca, combinação de espaçamento |
Me |
Marca, delimitador |
M |
Todas as marcas de combinação. Isso inclui as categorias Mn, Mc e Me. |
Nd |
Número, dígito decimal |
Nl |
Número, letra |
No |
Número, outro |
N |
Todos os números. Isso inclui as categorias Nd, Nl e No. |
Pc |
Pontuação, conector |
Pd |
Pontuação, traço |
Ps |
Pontuação, abertura |
Pe |
Pontuação, fechamento |
Pi |
Pontuação, aspas iniciais (podem se comportar como Ps ou Pe, dependendo do uso) |
Pf |
Pontuação, aspas finais (podem se comportar como Ps ou Pe, dependendo do uso) |
Po |
Pontuação, outros |
P |
Todos os caracteres de pontuação. Isso inclui as categorias Pc, Pd, Ps, Pe, Pi, Pf e Po. |
Sm |
Símbolo, matemático |
Sc |
Símbolo, moeda |
Sk |
Símbolo, modificador |
So |
Símbolo, outros |
S |
Todos os símbolos. Isso inclui as categorias Sm, Sc, Sk e So. |
Zs |
Separador, espaço |
Zl |
Separador, linha |
Zp |
Separador, parágrafo |
Z |
Todos os caracteres de separador. Isso inclui as categorias Zs, Zl e Zp. |
Cc |
Outros, controle |
Cf |
Outros, formato |
Cs |
Outros, substitutos |
Co |
Outros, uso privado |
Cn |
Outro, não atribuído ou não caractere |
C |
Todos os outros caracteres. Isso inclui as categorias Cc, Cf, Cs, Co e Cn. |
Você pode determinar a categoria Unicode de qualquer caractere específico ao passar esse caractere para o método GetUnicodeCategory. O exemplo a seguir usa o método GetUnicodeCategory para determinar a categoria de cada elemento em uma matriz que contém caracteres latinos selecionados.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
char[] chars = { 'a', 'X', '8', ',', ' ', '\u0009', '!' };
foreach (char ch in chars)
Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()),
Char.GetUnicodeCategory(ch));
}
}
// The example displays the following output:
// 'a': LowercaseLetter
// 'X': UppercaseLetter
// '8': DecimalDigitNumber
// ',': OtherPunctuation
// '\ ': SpaceSeparator
// '\t': Control
// '!': OtherPunctuation
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim chars() As Char = {"a"c, "X"c, "8"c, ","c, " "c, ChrW(9), "!"c}
For Each ch As Char In chars
Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()), _
Char.GetUnicodeCategory(ch))
Next
End Sub
End Module
' The example displays the following output:
' 'a': LowercaseLetter
' 'X': UppercaseLetter
' '8': DecimalDigitNumber
' ',': OtherPunctuation
' '\ ': SpaceSeparator
' '\t': Control
' '!': OtherPunctuation
Blocos nomeados compatíveis
O .NET fornece os blocos nomeados listados na tabela a seguir. O conjunto de blocos nomeados com suporte baseia-se no Unicode 4.0 e no Perl 5.6. Para uma expressão regular que usa blocos nomeados, consulte a seção Categoria Unicode ou bloco Unicode: \p{}.
| Intervalo de ponto de código | Nome do bloco |
|---|---|
| 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-ou- 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-ou- 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 ou 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 |
Subtração de classes de caractere: [base_group - [excluded_group]]
Uma classe de caracteres define um conjunto de caracteres. A subtração de classes de caracteres fornece um conjunto de caracteres que é o resultado da exclusão dos caracteres em uma classe de caracteres em outra classe de caracteres.
A expressão de subtração de classes de caracteres tem a seguinte forma:
[ base_group -[ excluded_group ]]
Os colchetes ([]) e hífen (-) são obrigatórios. O base_group é um grupo de caracteres positivos ou um grupo de caracteres negativos. O componente excluded_group é outro grupo de caracteres positivos ou negativos ou outra expressão de subtração de classes de caracteres (ou seja, você pode aninhar expressões de subtração de classes de caracteres).
Por exemplo, suponha que você tenha um grupo base que consiste no intervalo de caracteres de "a" a "z". Para definir o conjunto de caracteres que consiste no grupo base, exceto pelo caractere "m", use [a-z-[m]]. Para definir o conjunto de caracteres que consiste no grupo base, exceto pelo conjunto de caracteres "d", "j" e "p", use [a-z-[djp]]. Para definir o conjunto de caracteres que consiste no base consiste, exceto pelo intervalo de "m" a "p", use [a-z-[m-p]].
Considere a expressão de subtração de classes de caracteres aninhada, [a-z-[d-w-[m-o]]]. A expressão é calculada do intervalo de caracteres mais interno para fora. Primeiro, o intervalo de caracteres de "m" a "o" é subtraído do intervalo de caractere de "d" a "w", o que produz o conjunto de caracteres de "d" a "l" e "p" a "w". Esse conjunto é subtraído do intervalo de caracteres de "a" a "z", o que produz o conjunto de caracteres [abcmnoxyz].
Você pode usar qualquer classe de caracteres com a subtração de classes de caracteres. Para definir o conjunto de caracteres que consiste em todos os caracteres Unicode de \u0000 a \uFFFF, exceto caracteres de espaço em branco (\s), os caracteres na categoria geral de pontuação (\p{P}), os caracteres no bloco nomeado IsGreek (\p{IsGreek}) e o caractere de controle Unicode NEXT LINE (\x85), utilize [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].
Escolha classes de caracteres para uma expressão de subtração de classes de caracteres que produza resultados úteis. Evite uma expressão que gere um conjunto de caracteres vazio, que não podem corresponder a nada ou uma expressão equivalente ao grupo base original. Por exemplo, o conjunto vazio é o resultado da expressão [\p{IsBasicLatin}-[\x00-\x7F]], que subtrai todos os caracteres do intervalo de caracteres IsBasicLatin da categoria geral IsBasicLatin. Da mesma forma, o grupo base original é o resultado da expressão [a-z-[0-9]]. Isso ocorre, porque o grupo base, que é o intervalo de caracteres de letras de "a" a "z", não contém quaisquer caracteres no grupo excluído, que é o intervalo de caracteres de dígitos decimais de "0" a "9".
O exemplo a seguir define uma expressão regular, ^[0-9-[2468]]+$, que corresponde aos dígitos zero e ímpares em uma cadeia de caracteres de entrada. A expressão regular é interpretada conforme mostrado na tabela a seguir.
| Elemento | Descrição |
|---|---|
| ^ | Começar a correspondência no início da cadeia de caracteres de entrada. |
[0-9-[2468]]+ |
Corresponder a uma ou mais ocorrências de qualquer caractere de 0 a 9, com exceção de 2, 4, 6 e 8. Em outras palavras, corresponder a uma ou mais ocorrências de zero ou de um dígito ímpar. |
| $ | Finalizar a correspondência no final da cadeia de caracteres de entrada. |
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string[] inputs = { "123", "13579753", "3557798", "335599901" };
string pattern = @"^[0-9-[2468]]+$";
foreach (string input in inputs)
{
Match match = Regex.Match(input, pattern);
if (match.Success)
Console.WriteLine(match.Value);
}
}
}
// The example displays the following output:
// 13579753
// 335599901
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim inputs() As String = {"123", "13579753", "3557798", "335599901"}
Dim pattern As String = "^[0-9-[2468]]+$"
For Each input As String In inputs
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then Console.WriteLine(match.Value)
Next
End Sub
End Module
' The example displays the following output:
' 13579753
' 335599901
