Classes de caracteres em expressões regulares
Uma classe de caractere define um conjunto de caracteres, qualquer um dos quais pode ocorrer em uma cadeia de caracteres de entrada para que uma correspondência seja bem-sucedida. A linguagem de expressão regular no .NET suporta as seguintes classes de caracteres:
Grupos de caráter positivo. Um caractere na cadeia de caracteres de entrada deve corresponder a um de um conjunto especificado de caracteres. Para obter mais informações, consulte Grupo de caracteres positivos.
Grupos 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 Grupo de caracteres negativos.
Qualquer personagem. O
.caractere (ponto ou 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 Unicode geral ou um bloco nomeado. Um caractere na cadeia de caracteres de entrada deve ser membro de uma categoria 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 Categoria Unicode ou Bloco Unicode.
Uma categoria Unicode geral negativa ou um bloco nomeado. Um caractere na cadeia de caracteres de entrada não deve ser membro de uma categoria 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 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 apropriadas para caracteres em palavras. Para obter mais informações, consulte Caractere do Word.
Um caractere sem 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 Caractere não Word.
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 de vários caracteres de controle. Para obter mais informações, consulte Caractere de espaço em branco.
Um caractere sem 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 Caractere sem espaço em branco.
Um dígito decimal. Um caractere na cadeia de caracteres de entrada pode ser qualquer um de um número de caracteres classificados como dígitos decimais Unicode. Para obter mais informações, consulte Caractere de dígito decimal.
Um dígito não decimal. Um caractere na cadeia de caracteres de entrada pode ser qualquer coisa diferente de um dígito decimal Unicode. Para obter mais informações, consulte Caractere de dígito decimal.
O .NET oferece suporte a expressões de subtração de classe de caracteres, o que permite 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 caractere.
Nota
As classes de caracteres que correspondem a caracteres por categoria, como \w para corresponder a caracteres de palavra ou \p{} para corresponder a uma categoria Unicode, dependem da CharUnicodeInfo classe para fornecer informações sobre categorias de caracteres. No .NET Framework 4.6.2 e versões posteriores, as categorias de caracteres são baseadas no padrão Unicode, versão 8.0.0.
Grupo de caracteres positivos: [ ]
Um grupo de caracteres positivos especifica uma lista de caracteres, qualquer um dos quais pode aparecer em uma cadeia de caracteres de entrada para que ocorra uma correspondência. Esta 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*]
onde 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 consistir em 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]
onde firstCharacter é o caractere que inicia o intervalo e lastCharacter é o caractere que termina o intervalo. Um intervalo de caracteres é uma série contígua de caracteres definida especificando o primeiro caractere da série, um hífen (-) e, em seguida, o último caractere da série. Dois caracteres são contíguos se tiverem pontos de código Unicode adjacentes. firstCharacter deve ser o caractere com o ponto de código inferior e lastCharacter deve ser o caractere com o ponto de código mais alto.
Nota
Como um grupo de caracteres positivo 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 seja o primeiro ou o último caractere do grupo.
Para incluir um hífen como 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 - para /, a sintaxe correta é [a\--/].
Alguns padrões comuns de expressão regular que contêm classes de caracteres positivos estão listados na tabela a seguir.
| Padrão | Description |
|---|---|
[aeiou] |
Corresponda a todas as vogais. |
[\p{P}\d] |
Corresponder a todos os caracteres de pontuação e dígitos decimais. |
[\s\p{P}] |
Combine 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 "cinza" ou "cinza" seguidas por outra palavra para que ocorra uma correspondência.
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 gr[ae]y\s\S+?[\s|\p{P}] regular é definida da seguinte forma:
| Padrão | Description |
|---|---|
gr |
Corresponda aos caracteres literais "gr". |
[ae] |
Corresponder a um "a" ou a um "e". |
y\s |
Corresponder ao caractere literal "y" seguido por um caractere de espaço em branco. |
\S+? |
Corresponder a um ou mais caracteres sem 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 \b[A-Z]\w*\b regular é definida conforme mostrado na tabela a seguir.
| Padrão | Description |
|---|---|
\b |
Comece com um limite de palavras. |
[A-Z] |
Corresponder qualquer caractere maiúsculo de A a Z. |
\w* |
Corresponder a zero ou mais caracteres de palavras. |
\b |
Corresponder a um limite de palavras. |
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 ocorra uma correspondência. 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*]
onde 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 consistir em 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*]
onde firstCharacter é o caractere que inicia o intervalo e lastCharacter é o caractere que termina o intervalo. Um intervalo de caracteres é uma série contígua de caracteres definida especificando o primeiro caractere da série, um hífen (-) e, em seguida, o último caractere da série. Dois caracteres são contíguos se tiverem pontos de código Unicode adjacentes. firstCharacter deve ser o caractere com o ponto de código inferior e lastCharacter deve ser o caractere com o ponto de código mais alto.
Nota
Como 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 seja o primeiro ou o ú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 de "A" a "F", use [0-9a-fA-F].
O caractere de acento circunflexo principal (^) em um grupo de caracteres negativos é obrigatório e indica que o grupo de caracteres é um grupo de caracteres negativos em vez de um grupo de caracteres positivos.
Importante
Um grupo de caracteres negativos em um padrão de 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ão regular avança um caractere na cadeia de caracteres de entrada.
Alguns padrões comuns de expressão regular que contêm grupos de caracteres negativos estão listados na tabela a seguir.
| Padrão | Description |
|---|---|
[^aeiou] |
Corresponder a todos os caracteres, exceto vogais. |
[^\p{P}\d] |
Corresponder a todos os caracteres, exceto pontuação e caracteres de dígitos decimais. |
O exemplo a seguir corresponde a qualquer palavra que começa com os caracteres "th" e não é seguida 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 \bth[^o]\w+\b regular é definida conforme mostrado na tabela a seguir.
| Padrão | Description |
|---|---|
\b |
Comece com um limite de palavras. |
th |
Corresponda aos caracteres literais "th". |
[^o] |
Combine qualquer caractere que não seja um "o". |
\w+ |
Corresponder a um ou mais caracteres de palavra. |
\b |
Termine com um limite de palavras. |
Qualquer personagem: .
O caractere de ponto (.) corresponde a qualquer caractere, exceto \n (o caractere de nova linha), com as seguintes duas qualificações:
Se um padrão de expressão regular for modificado pela RegexOptions.Singleline opção, ou se a parte do padrão que contém a
.classe de caractere for modificada pelasopção,.corresponder a qualquer caractere. Para obter mais informações, consulte Opções de expressão regular.O exemplo a seguir ilustra o comportamento diferente da classe de
.caractere por padrão e com a RegexOptions.Singleline opção. 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,\rmas não corresponde a\n. Como a RegexOptions.Singleline opção interpreta toda a cadeia de caracteres de entrada como uma única linha, ela corresponde a todos os caracteres da cadeia 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\.
Nota
Como ele corresponde a qualquer caractere, exceto \n, a classe de . caractere também corresponde \r (o caractere de retorno de carro).
Em um grupo de caracteres positivos ou negativos, um ponto é tratado como um caractere de período literal, e não como uma classe de caracteres. Para obter mais informações, consulte Grupo de caracteres positivos e Grupo de caracteres negativos anteriormente neste tópico. O exemplo a seguir fornece uma ilustração definindo uma expressão regular que inclui o caractere de ponto (
.) como uma classe de caractere e como um membro de um grupo de caracteres positivos. A expressão\b.*[.?!;:](\s|\z)regular começa em um limite de palavras, corresponde a qualquer caractere até encontrar um dos cinco sinais de pontuação, incluindo um ponto, e então 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.
Nota
Como ele corresponde a qualquer caractere, o . elemento de linguagem é frequentemente usado com um quantificador preguiçoso se um padrão de expressão regular tentar corresponder a qualquer caractere várias vezes. Para obter mais informações, consulte Quantifiers.
Categoria 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 Lu (representada pela categoria), um dígito decimal (a Nd categoria), um símbolo matemático (a Sm categoria) ou um separador de parágrafo (a Zl categoria). Conjuntos de caracteres específicos no padrão Unicode também ocupam um intervalo ou bloco específico de pontos de código consecutivos. Por exemplo, o conjunto básico de caracteres latinos é encontrado de \u0000 até \u007F, enquanto o conjunto de caracteres árabes é encontrado de \u0600 até \u06FF.
A construção da expressão regular
\p{Designação}
corresponde a qualquer caractere que pertença a uma categoria geral Unicode ou bloco nomeado, onde nome é a abreviatura da categoria ou nome do bloco nomeado. Para obter uma lista de abreviaturas de categoria, consulte a seção Categorias gerais Unicode suportadas mais adiante neste tópico. Para obter uma lista de blocos nomeados, consulte a seção Blocos nomeados suportados mais adiante neste tópico.
Gorjeta
A correspondência pode ser melhorada se a cadeia de caracteres for normalizada pela primeira vez chamando o String.Normalize método.
O exemplo a seguir usa a \p{construção name} para corresponder a uma categoria geral Unicode (neste caso, a Pdcategoria , ou Pontuação, Traço) e um bloco nomeado (os IsGreek blocos e IsBasicLatin nomeados).
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 \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ regular é definida conforme mostrado na tabela a seguir.
| Padrão | Description |
|---|---|
\b |
Comece com um limite de palavras. |
\p{IsGreek}+ |
Corresponda 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} |
Corresponda a um caractere de pontuação, traço. |
\s |
Corresponder a um caractere de espaço em branco. |
\p{IsBasicLatin}+ |
Corresponder a um ou mais caracteres latinos básicos. |
(\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 Lu (representada pela categoria), um dígito decimal (a Nd categoria), um símbolo matemático (a Sm categoria) ou um separador de parágrafo (a Zl categoria). Conjuntos de caracteres específicos no padrão Unicode também ocupam um intervalo ou bloco específico de pontos de código consecutivos. Por exemplo, o conjunto básico de caracteres latinos é encontrado de \u0000 até \u007F, enquanto o conjunto de caracteres árabes é encontrado de \u0600 até \u06FF.
A construção da expressão regular
\P{Designação}
corresponde a qualquer caractere que não pertença a uma categoria geral Unicode ou bloco nomeado, onde nome é a abreviatura da categoria ou nome do bloco nomeado. Para obter uma lista de abreviaturas de categoria, consulte a seção Categorias gerais Unicode suportadas mais adiante neste tópico. Para obter uma lista de blocos nomeados, consulte a seção Blocos nomeados suportados mais adiante neste tópico.
Gorjeta
A correspondência pode ser melhorada se a cadeia de caracteres for normalizada pela primeira vez chamando o String.Normalize método.
O exemplo a seguir usa a \P{construção name} para remover quaisquer símbolos de moeda (neste caso, a Sccategoria , ou Symbol, Currency) 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 (\P{Sc})+ de expressão regular corresponde a um ou mais caracteres que não são símbolos de moeda, ele efetivamente remove qualquer símbolo de moeda da cadeia de caracteres de resultado.
Caractere da 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 | Description |
|---|---|
| Ll | Carta, Lowercase |
| Lu | Letra, maiúsculas |
| Lt | Carta, Título: |
| Lo | Carta, Outros |
| Lm | Letra, Modificador |
| Mn | marca, sem espaçamento |
| Nd | Número, dígito decimal |
| Pc | Pontuação, Conector. Esta categoria inclui dez caracteres, o mais comumente usado é o caractere 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 "ECMAScript Matching Behavior" em Opções de expressão regular.
Nota
Como corresponde a qualquer caractere de palavra, o \w elemento de linguagem é frequentemente usado com um quantificador preguiçoso se um padrão de expressão regular tentar corresponder a qualquer caractere de palavra várias vezes, seguido por um caractere de palavra específico. Para obter mais informações, consulte Quantifiers.
O exemplo a seguir usa o \w elemento language para corresponder caracteres duplicados em uma palavra. O exemplo define um padrão de expressão regular, (\w)\1, que pode ser interpretado da seguinte forma.
| Elemento | Description |
|---|---|
| (\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-palavra: \W
\W corresponde a qualquer caractere não-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, exceto aqueles nas categorias Unicode listadas na tabela a seguir.
| Categoria | Description |
|---|---|
| Ll | Carta, Lowercase |
| Lu | Letra, maiúsculas |
| Lt | Carta, Título: |
| Lo | Carta, Outros |
| Lm | Letra, Modificador |
| Mn | marca, sem espaçamento |
| Nd | Número, dígito decimal |
| Pc | Pontuação, Conector. Esta categoria inclui dez caracteres, o mais comumente usado é o caractere 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 "ECMAScript Matching Behavior" em Opções de expressão regular.
Nota
Como ele corresponde a qualquer caractere não-palavra, o \W elemento de linguagem é freqüentemente usado com um quantificador preguiçoso se um padrão de expressão regular tenta corresponder a qualquer caractere não-palavra várias vezes seguido por um caractere não-palavra específico. Para obter mais informações, consulte Quantifiers.
O exemplo a seguir ilustra a \W classe de caractere. 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 verbais, como espaço em branco ou pontuação. A expressão regular é interpretada como mostrado na tabela a seguir.
| Elemento | Description |
|---|---|
| \b | Comece a partida com um limite de palavras. |
| (\w+) | Corresponder a um ou mais caracteres de palavra. Este é o primeiro grupo de captura. |
| (\W){1,2} | Corresponder um caractere não-palavra 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 Group objeto para o segundo grupo de captura contém apenas um único caractere não-palavra capturado, o exemplo recupera todos os caracteres não-palavra capturados do CaptureCollection objeto retornado pela Group.Captures propriedade.
Caractere de espaço em branco: \s
\s corresponde a qualquer caractere de espaço em branco. É equivalente às sequências de escape e categorias Unicode listadas na tabela a seguir.
| Categoria | Description |
|---|---|
\f |
O caractere de alimentação de formulário, \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 o Zs, Zle Zp categorias. |
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 "ECMAScript Matching Behavior" em Opções de expressão regular.
O exemplo a seguir ilustra a \s classe de caractere. Ele define um padrão de expressão regular, \b\w+(e)?s(\s|$), que corresponde a uma palavra terminada em "s" ou "es" seguida por um caractere de espaço em branco ou o final da cadeia de caracteres de entrada. A expressão regular é interpretada como mostrado na tabela a seguir.
| Elemento | Description |
|---|---|
| \b | Comece a partida com um limite de palavras. |
| \w+ | Corresponder a um ou mais caracteres de palavra. |
| (e)? | Corresponder a um "e" zero ou uma vez. |
| s | Corresponda a um "s". |
| (\s|$) | Corresponder a um caractere de espaço em branco ou ao final 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 sem espaço em branco: \S
\S corresponde a qualquer caractere que não seja de espaço em branco. É equivalente ao [^\f\n\r\t\v\x85\p{Z}] padrão de expressão regular, ou o oposto do padrão de expressão regular que é equivalente a , que corresponde a \scaracteres de espaço em branco. Para obter mais informações, consulte 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 "ECMAScript Matching Behavior" em Opções de expressão regular.
O exemplo a seguir ilustra o \S elemento language. O padrão \b(\S+)\s? de expressão regular corresponde a cadeias de caracteres delimitadas por caracteres de espaço em branco. O segundo elemento no objeto da correspondência contém a cadeia de GroupCollection caracteres correspondente. A expressão regular pode ser interpretada como mostrado na tabela a seguir.
| Elemento | Description |
|---|---|
\b |
Comece a partida com um limite de palavras. |
(\S+) |
Corresponder a um ou mais caracteres sem 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 \p{Nd} padrão de expressão regular, que 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 "ECMAScript Matching Behavior" em Opções de expressão regular.
O exemplo a seguir ilustra o \d elemento language. 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 ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ de expressão regular é definido conforme mostrado na tabela a seguir.
| Elemento | Description |
|---|---|
^ |
Comece 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 um caractere de espaço em branco. |
(\(?\d{3}\)?[\s-])? |
Corresponder a um parêntese de abertura opcional seguido de 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 a três dígitos decimais seguidos de 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 sem dígitos: \D
\D corresponde a qualquer caractere sem dígitos. É equivalente ao padrão de \P{Nd} expressão regular.
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 "ECMAScript Matching Behavior" em Opções de expressão regular.
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 ^\D\d{1,5}\D*$ de expressão regular é definido conforme mostrado na tabela a seguir.
| Elemento | Description |
|---|---|
^ |
Comece a correspondência no início da cadeia de caracteres de entrada. |
\D |
Corresponder a um caractere sem dígitos. |
\d{1,5} |
Corresponder de um a cinco dígitos decimais. |
\D* |
Corresponder zero, 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 suportadas
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 gerais de categoria" no banco de dados de caracteres Unicode, Seção 5.7.1, Tabela 12.
| Categoria | Description |
|---|---|
Lu |
Letra, maiúsculas |
Ll |
Carta, Lowercase |
Lt |
Carta, Título: |
Lm |
Letra, Modificador |
Lo |
Carta, Outros |
L |
Todos os caracteres de letra. Isso inclui os Lucaracteres , Ll, Lt, Lm, e Lo . |
Mn |
marca, sem espaçamento |
Mc |
Marca, combinação de espaçamento |
Me |
Marcos, Anexando |
M |
Todos combinando marcas. Isso inclui o Mn, Mce Me categorias. |
Nd |
Número, dígito decimal |
Nl |
Número, letra |
No |
Número, Outros |
N |
Todos os números. Isso inclui o Nd, Nle No categorias. |
Pc |
Pontuação, Conector |
Pd |
Pontuação, traço |
Ps |
Pontuação, Aberto |
Pe |
Pontuação, Fechar |
Pi |
Pontuação, Citação inicial (pode comportar-se como Ps ou Pe dependendo do uso) |
Pf |
Pontuação, Citação final (pode comportar-se como Ps ou Pe dependendo do uso) |
Po |
Pontuação, Outros |
P |
Todos os caracteres de pontuação. Isso inclui as Pccategorias , Pd, Ps, Pe, PfPi, e Po . |
Sm |
Símbolo, Matemática |
Sc |
Símbolo, Moeda |
Sk |
Símbolo, Modificador |
So |
Símbolo, Outro |
S |
Todos os símbolos. Isso inclui as Smcategorias , Sc, Sk, e So . |
Zs |
Separador, Espaço |
Zl |
Separador, Linha |
Zp |
Separador, Parágrafo |
Z |
Todos os caracteres separadores. Isso inclui o Zs, Zle Zp categorias. |
Cc |
Outro, Controlo |
Cf |
Outro, Formato |
Cs |
Outro, Substituto |
Co |
Outros, Uso Privado |
Cn |
Outros, não atribuídos ou sem caráter |
C |
Todos os outros personagens. Isso inclui as Cccategorias , Cf, Cs, Co, e Cn . |
Você pode determinar a categoria Unicode de qualquer caractere específico passando esse caractere para o GetUnicodeCategory método. O exemplo a seguir usa o GetUnicodeCategory método 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 suportados
O .NET fornece os blocos nomeados listados na tabela a seguir. O conjunto de blocos nomeados suportados é baseado em Unicode 4.0 e Perl 5.6. Para obter uma expressão regular que usa blocos nomeados, consulte a categoria Unicode ou bloco Unicode: seção \p{} .
| Intervalo de pontos 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-or- 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 - 0FEP | 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 - 17 e seguintes | IsKhmer |
| 1800 - 18AF | IsMongolian |
| 1900 - 194F | IsLimbu |
| 1950 - 197F | IsTaiLe |
| 19E0 - 19FF | IsKhmerSymbols |
| 1D00 - 1D7F | IsPhoneticExtensions |
| 1E00 - 1FEP | IsLatinExtendedAdditional |
| 1F00 - 1FFF | IsGreekExtended |
| 2000 - 206F | IsGeneralPunctuation |
| 2070 - 209F | IsSuperscriptsandSubscripts |
| 20A0 - 20CF | IsCurrencySymbols |
| 20D0 - 20FF | IsCombiningDiacriticalMarksforSymbols-or- IsCombiningMarksforSymbols |
| 2100 - 214F | IsLetterlikeSymbols |
| 2150 - 218F | IsNumberForms |
| 2190 - 21 e seguintes | IsArrows |
| 2200 - 22 e seguintes | IsMathematicalOperators |
| 2300 - 23FF | IsMiscellaneousTechnical |
| 2400 - 243F | IsControlPictures |
| 2440 - 245F | IsOpticalCharacterRecognition |
| 2460 - 24 e seguintes | 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 - 29 e seguintes | IsMiscellaneousMathematicalSymbols-B |
| 2A00 - 2AFF | IsSupplementalMathematicalOperators |
| 2B00 - 2BFF | IsMiscellaneousSymbolsandArrows |
| 2E80 - 2FEP | 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 - 32 e seguintes | IsEnclosedCJKLettersandMonths |
| 3300 - 33 e seguintes | 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 classe de caractere: [base_group - [excluded_group]]
Uma classe de caracteres define um conjunto de caracteres. A subtração da classe de caracteres produz um conjunto de caracteres que é o resultado da exclusão dos caracteres de uma classe de caracteres de outra classe de caracteres.
Uma expressão de subtração de classe de caractere tem a seguinte forma:
[-[base_group excluded_group]]
Os colchetes ([]) e o 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 positivo ou negativo, ou outra expressão de subtração de classe de caractere (ou seja, você pode aninhar expressões de subtração de classe de caractere).
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 para o caractere "m", use [a-z-[m]]. Para definir o conjunto de caracteres que consiste no grupo base, exceto para o conjunto de caracteres "d", "j" e "p", use [a-z-[djp]]. Para definir o conjunto de caracteres que consiste no grupo base, exceto para o intervalo de caracteres de "m" a "p", use [a-z-[m-p]].
Considere a expressão de subtração da classe de caractere aninhada, [a-z-[d-w-[m-o]]]. A expressão é avaliada a partir da faixa de caracteres mais interna para fora. Primeiro, o intervalo de caracteres de "m" a "o" é subtraído do intervalo de caracteres "d" a "w", o que produz o conjunto de caracteres de "d" a "l" e "p" a "w". Esse conjunto é então subtraído do intervalo de caracteres de "a" a "z", o que produz o conjunto de caracteres [abcmnoxyz].
Você pode usar qualquer classe de caractere com subtração de classe de caractere. 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 IsGreek bloco nomeado (\p{IsGreek}) e o caractere de controle Unicode NEXT LINE (\x85), use [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].
Escolha classes de caracteres para uma expressão de subtração de classe de caractere que produzirá resultados úteis. Evite uma expressão que produza um conjunto vazio de caracteres, que não possa corresponder a nada, ou uma expressão que seja 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 IsBasicLatin intervalo de caracteres da IsBasicLatin categoria geral. 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 nenhum caractere 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 a zero e dígitos ímpares em uma cadeia de caracteres de entrada. A expressão regular é interpretada como mostrado na tabela a seguir.
| Elemento | Description |
|---|---|
| ^ | Comece a partida no início da cadeia de caracteres de entrada. |
[0-9-[2468]]+ |
Corresponder uma ou mais ocorrências de qualquer caractere de 0 a 9, exceto 2, 4, 6 e 8. Em outras palavras, corresponda a uma ou mais ocorrências de zero ou um dígito ímpar. |
| $ | Termine a partida 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
Consulte também
Comentários
Brevemente: Ao longo de 2024, vamos descontinuar progressivamente o GitHub Issues como mecanismo de feedback para conteúdos e substituí-lo por um novo sistema de feedback. Para obter mais informações, veja: https://aka.ms/ContentUserFeedback.
Submeter e ver comentários