Classes de caracteres em expressões regularesCharacter classes in regular expressions

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 character class defines a set of characters, any one of which can occur in an input string for a match to succeed. A linguagem de expressões regulares no .NET dá suporte às seguintes classes de caracteres:The regular expression language in .NET supports the following character classes:

  • Grupos de caracteres positivos.Positive character groups. Um caractere na cadeia de caracteres de entrada deve corresponder a um de um conjunto especificado de caracteres.A character in the input string must match one of a specified set of characters. Para obter mais informações, consulte Positive Character Group (Grupo de caracteres positivos).For more information, see Positive Character Group.

  • Grupo de caracteres negativos.Negative character groups. Um caractere na cadeia de caracteres de entrada não deve corresponder a um de um conjunto especificado de caracteres.A character in the input string must not match one of a specified set of characters. Para obter mais informações, consulte Negative Character Group (Grupo de caracteres negativos).For more information, see Negative Character Group.

  • Caractere qualquer.Any character. O . (ponto) em uma expressão regular é um caractere curinga que corresponde a qualquer caractere, exceto \n.The . (dot or period) character in a regular expression is a wildcard character that matches any character except \n. Para obter mais informações, consulte Qualquer caractere.For more information, see Any Character.

  • Uma categoria geral de Unicode ou bloco nomeado.A general Unicode category or named block. 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.A character in the input string must be a member of a particular Unicode category or must fall within a contiguous range of Unicode characters for a match to succeed. Para obter mais informações, consulte Unicode Category or Unicode Block (Bloco de Unicode ou Categoria de Unicode).For more information, see Unicode Category or Unicode Block.

  • Uma categoria geral de Unicode ou bloco nomeado negativos.A negative general Unicode category or named block. 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.A character in the input string must not be a member of a particular Unicode category or must not fall within a contiguous range of Unicode characters for a match to succeed. Para obter mais informações, consulte Negative Unicode Category or Unicode Block (Categoria Unicode Negativa ou bloco Unicode).For more information, see Negative Unicode Category or Unicode Block.

  • Um caractere de palavra.A word character. 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.A character in the input string can belong to any of the Unicode categories that are appropriate for characters in words. Para obter mais informações, consulte Word Character (Caractere de palavra).For more information, see Word Character.

  • Um caractere não pertencente a palavras.A non-word character. Um caractere na cadeia de caracteres de entrada pode pertencer a qualquer categoria Unicode que não seja um caractere de palavra.A character in the input string can belong to any Unicode category that is not a word character. Para obter mais informações, consulte Non-Word Character (Caractere não pertencente a palavras).For more information, see Non-Word Character.

  • Um caractere de espaço em branco.A white-space character. Um caractere na cadeia de caracteres de entrada pode ser qualquer caractere separador Unicode, bem como qualquer um entre vários caracteres de controle.A character in the input string can be any Unicode separator character, as well as any one of a number of control characters. Para obter mais informações, consulte White-Space Character (Caractere de espaço em branco).For more information, see White-Space Character.

  • Um caractere diferente de espaço em branco.A non-white-space character. Um caractere na cadeia de caracteres de entrada pode ser qualquer caractere que não seja um caractere de espaço em branco.A character in the input string can be any character that is not a white-space character. Para obter mais informações, consulte Non-White-Space Character (Caractere diferente de espaço em branco).For more information, see Non-White-Space Character.

  • Um dígito decimal.A decimal digit. Um caractere na cadeia de caracteres de entrada pode ser qualquer um entre vários caracteres classificados como dígitos decimais Unicode.A character in the input string can be any of a number of characters classified as Unicode decimal digits. Para obter mais informações, consulte Decimal Digit Character (Caractere de dígito decimal).For more information, see Decimal Digit Character.

  • Um dígito não decimal.A non-decimal digit. Um caractere na cadeia de caracteres de entrada pode ser qualquer coisa que não seja um dígito decimal Unicode.A character in the input string can be anything other than a Unicode decimal digit. Para obter mais informações, consulte Decimal Digit Character (Caractere de dígito decimal).For more information, see Decimal Digit Character.

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..NET supports character class subtraction expressions, which enables you to define a set of characters as the result of excluding one character class from another character class. Para obter mais informações, consulte Subtração de classe de caracteres.For more information, see Character Class Subtraction.

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.Character classes that match characters by category, such as \w to match word characters or \p{} to match a Unicode category, rely on the CharUnicodeInfo class to provide information about character categories. Do .NET Framework 4.6.2 em diante, as categorias de caracteres se baseiam no Padrão Unicode, versão 8.0.0.Starting with the .NET Framework 4.6.2, character categories are based on The Unicode Standard, Version 8.0.0. No .NET Framework 4 até o .NET Framework 4.6.1, eles se baseiam no Padrão Unicode, versão 6.3.0.In the .NET Framework 4 through the .NET Framework 4.6.1, they are based on The Unicode Standard, Version 6.3.0.

Grupo de caracteres positivo: [ ]Positive character group: [ ]

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.A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. Essa lista de caracteres pode ser especificada individualmente, como um intervalo ou ambos.This list of characters may be specified individually, as a range, or both.

A sintaxe para especificar uma lista de caracteres individuais é a seguinte:The syntax for specifying a list of individual characters is as follows:

[*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.where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group pode ser composto por qualquer combinação de um ou mais caracteres literais, caracteres de escape ou classes de caracteres.character_group can consist of any combination of one or more literal characters, escape characters, or character classes.

A sintaxe para especificar um intervalo de caracteres é a seguinte:The syntax for specifying a range of characters is as follows:

[firstCharacter-lastCharacter]

em que firstCharacter é o caractere que inicia o intervalo e lastCharacter é o caractere que encerra o intervalo.where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. 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.A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Dois caracteres são contíguos se eles têm pontos de código Unicode adjacentes.Two characters are contiguous if they have adjacent Unicode code points. 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.firstCharacter must be the character with the lower code point, and lastCharacter must be the character with the higher code point.

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.Because a positive character group can include both a set of characters and a character range, a hyphen character (-) is always interpreted as the range separator unless it is the first or last character of the group.

Alguns padrões de expressões regulares comuns que contêm classes de caracteres positivos são listados na tabela a seguir.Some common regular expression patterns that contain positive character classes are listed in the following table.

PatternPattern DescriçãoDescription
[aeiou] Corresponder a todas as vogais.Match all vowels.
[\p{P}\d] Corresponder a todos os caracteres de pontuação e dígitos decimais.Match all punctuation and decimal digit characters.
[\s\p{P}] Corresponder a todos os espaços em branco e à pontuação.Match all white space and punctuation.

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.The following example defines a positive character group that contains the characters "a" and "e" so that the input string must contain the words "grey" or "gray" followed by another word for a match to occur.

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:The regular expression gr[ae]y\s\S+?[\s|\p{P}] is defined as follows:

PatternPattern DescriçãoDescription
gr Corresponder aos caracteres literais “gr”.Match the literal characters "gr".
[ae] Corresponder a um "a" ou "e".Match either an "a" or an "e".
y\s Corresponder ao caractere literal “y” seguido por um caractere de espaço em branco.Match the literal character "y" followed by a white-space character.
\S+? Corresponder a um ou mais caracteres diferentes de espaço em branco, mas o mínimo possível.Match one or more non-white-space characters, but as few as possible.
[\s\p{P}] Corresponder a um caractere de espaço em branco ou a um sinal de pontuação.Match either a white-space character or a punctuation mark.

O exemplo a seguir corresponde a palavras que começam com qualquer letra maiúscula.The following example matches words that begin with any capital letter. Ele usa a subexpressão [A-Z] para representar o intervalo de letras maiúsculas de A a Z.It uses the subexpression [A-Z] to represent the range of capital letters from A to 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.The regular expression \b[A-Z]\w*\b is defined as shown in the following table.

PatternPattern DescriçãoDescription
\b Iniciar em um limite de palavra.Start at a word boundary.
[A-Z] Corresponder a qualquer caractere maiúsculo de A a Z.Match any uppercase character from A to Z.
\w* Corresponder a zero ou mais caracteres de palavra.Match zero or more word characters.
\b Corresponder a um limite de palavra.Match a word boundary.

Grupo de caracteres negativos: [^]Negative character group: [^]

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 negative character group specifies a list of characters that must not appear in an input string for a match to occur. A lista de caracteres pode ser especificada individualmente, como um intervalo ou ambos.The list of characters may be specified individually, as a range, or both.

A sintaxe para especificar uma lista de caracteres individuais é a seguinte:The syntax for specifying a list of individual characters is as follows:

[*^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.where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group pode ser composto por qualquer combinação de um ou mais caracteres literais, caracteres de escape ou classes de caracteres.character_group can consist of any combination of one or more literal characters, escape characters, or character classes.

A sintaxe para especificar um intervalo de caracteres é a seguinte:The syntax for specifying a range of characters is as follows:

[^*firstCharacter*-*lastCharacter*]

em que firstCharacter é o caractere que inicia o intervalo e lastCharacter é o caractere que encerra o intervalo.where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. 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.A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Dois caracteres são contíguos se eles têm pontos de código Unicode adjacentes.Two characters are contiguous if they have adjacent Unicode code points. 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.firstCharacter must be the character with the lower code point, and lastCharacter must be the character with the higher code point.

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.Because a negative character group can include both a set of characters and a character range, a hyphen character (-) is always interpreted as the range separator unless it is the first or last character of the group.

Dois ou mais intervalos de caracteres podem ser concatenados.Two or more character ranges can be concatenated. 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].For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "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.The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.

Importante

Um grupo de caracteres negativos em uma expressão regular maior não é uma asserção de largura zero.A negative character group in a larger regular expression pattern is not a zero-width assertion. 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.That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.

Alguns padrões de expressões regulares comuns que contêm grupos de caracteres negativos são listados na tabela a seguir.Some common regular expression patterns that contain negative character groups are listed in the following table.

PatternPattern DescriçãoDescription
[^aeiou] Corresponder a todos os caracteres, exceto vogais.Match all characters except vowels.
[^\p{P}\d] Corresponder a todos os caracteres, exceto de pontuação e dígitos decimais.Match all characters except punctuation and decimal digit characters.

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”.The following example matches any word that begins with the characters "th" and is not followed by an "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.The regular expression \bth[^o]\w+\b is defined as shown in the following table.

PatternPattern DescriçãoDescription
\b Iniciar em um limite de palavra.Start at a word boundary.
th Corresponder aos caracteres literais “th”.Match the literal characters "th".
[^o] Corresponder a qualquer caractere que não seja um “o”.Match any character that is not an "o".
\w+ Corresponde a um ou mais caracteres de palavra.Match one or more word characters.
\b Terminar em um limite de palavra.End at a word boundary.

Qualquer caractere: .Any character: .

O caractere de ponto (.) corresponde a qualquer caractere, exceto \n (o caractere de nova linha, \u000A), com estas duas qualificações:The period character (.) matches any character except \n (the newline character, \u000A), with the following two qualifications:

  • 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ção s, . corresponde a qualquer caractere.If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the s option, . matches any character. Para obter mais informações, consulte Opções de expressões regulares.For more information, see Regular Expression Options.

    O exemplo a seguir ilustra o comportamento diferente da classe de caracteres . por padrão e com a opção RegexOptions.Singleline.The following example illustrates the different behavior of the . character class by default and with the RegexOptions.Singleline option. A expressão regular ^.+ começa no início da cadeia de caracteres e corresponde a todos os caracteres.The regular expression ^.+ starts at the beginning of the string and matches every character. 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 ou \ u000D, mas não corresponde a \n.By default, the match ends at the end of the first line; the regular expression pattern matches the carriage return character, \r or \u000D, but it does not match \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.Because the RegexOptions.Singleline option interprets the entire input string as a single line, it matches every character in the input string, including \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, \u000D).Because it matches any character except \n, the . character class also matches \r (the carriage return character, \u000D).

  • 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.In a positive or negative character group, a period is treated as a literal period character, and not as a character class. Para saber mais, confira Grupo de caracteres positivos e Grupo de caracteres negativos anteriormente neste tópico.For more information, see Positive Character Group and Negative Character Group earlier in this topic. 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.The following example provides an illustration by defining a regular expression that includes the period character (.) both as a character class and as a member of a positive character group. 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.The regular expression \b.*[.?!;:](\s|\z) begins at a word boundary, matches any character until it encounters one of five punctuation marks, including a period, and then matches either a white-space character or the end of the string.

    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.Because it matches any character, the . language element is often used with a lazy quantifier if a regular expression pattern attempts to match any character multiple times. Para saber mais, confira Quantificadores.For more information, see Quantifiers.

Categoria de Unicode ou bloco Unicode: \p{}Unicode category or Unicode block: \p{}

O padrão Unicode atribui a cada caractere uma categoria geral.The Unicode standard assigns each character a general category. 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).For example, a particular character can be an uppercase letter (represented by the Lu category), a decimal digit (the Nd category), a math symbol (the Sm category), or a paragraph separator (the Zl category). 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.Specific character sets in the Unicode standard also occupy a specific range or block of consecutive code points. 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.For example, the basic Latin character set is found from \u0000 through \u007F, while the Arabic character set is found from \u0600 through \u06FF.

A constructo da expressão regularThe regular expression construct

\p{ nome }\p{ name }

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.matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. Para obter uma lista de abreviações de categoria, consulte a seção Categorias gerais Unicode com suporte posteriormente neste tópico.For a list of category abbreviations, see the Supported Unicode General Categories section later in this topic. Para obter uma lista dos blocos nomeados, consulte a seção Blocos nomeados com suporte posteriormente neste tópico.For a list of named blocks, see the Supported Named Blocks section later in this topic.

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).The following example uses the \p{name} construct to match both a Unicode general category (in this case, the Pd, or Punctuation, Dash category) and a named block (the IsGreek and IsBasicLatin named blocks).

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.The regular expression \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ is defined as shown in the following table.

PatternPattern DescriçãoDescription
\b Iniciar em um limite de palavra.Start at a word boundary.
\p{IsGreek}+ Corresponder a um ou mais caracteres gregos.Match one or more Greek characters.
(\s)? Corresponder a zero ou a um caractere de espaço em branco.Match zero or one white-space character.
(\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.Match the pattern of one or more Greek characters followed by zero or one white-space characters one or more times.
\p{Pd} Corresponder a um caractere de pontuação, traço.Match a Punctuation, Dash character.
\s Corresponde a um caractere de espaço em branco.Match a white-space character.
\p{IsBasicLatin}+ Corresponder a um ou mais caracteres latinos.Match one or more basic Latin characters.
(\s)? Corresponder a zero ou a um caractere de espaço em branco.Match zero or one white-space character.
(\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.Match the pattern of one or more basic Latin characters followed by zero or one white-space characters one or more times.

Categoria Unicode negativa ou bloco Unicode: \P{}Negative Unicode category or Unicode block: \P{}

O padrão Unicode atribui a cada caractere uma categoria geral.The Unicode standard assigns each character a general category. 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).For example, a particular character can be an uppercase letter (represented by the Lu category), a decimal digit (the Nd category), a math symbol (the Sm category), or a paragraph separator (the Zl category). 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.Specific character sets in the Unicode standard also occupy a specific range or block of consecutive code points. 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.For example, the basic Latin character set is found from \u0000 through \u007F, while the Arabic character set is found from \u0600 through \u06FF.

A constructo da expressão regularThe regular expression construct

\P{ nome }\P{ name }

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.matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. Para obter uma lista de abreviações de categoria, consulte a seção Categorias gerais Unicode com suporte posteriormente neste tópico.For a list of category abbreviations, see the Supported Unicode General Categories section later in this topic. Para obter uma lista dos blocos nomeados, consulte a seção Blocos nomeados com suporte posteriormente neste tópico.For a list of named blocks, see the Supported Named Blocks section later in this topic.

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.The following example uses the \P{name} construct to remove any currency symbols (in this case, the Sc, or Symbol, Currency category) from numeric strings.

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.The regular expression pattern (\P{Sc})+ matches one or more characters that are not currency symbols; it effectively strips any currency symbol from the result string.

Caractere de palavra: \wWord character: \w

\w corresponde a qualquer caractere de palavra.\w matches any word character. Um caractere de palavra é um membro de qualquer uma das categorias Unicode listadas na tabela a seguir.A word character is a member of any of the Unicode categories listed in the following table.

CategoriaCategory DescriçãoDescription
LILl Letra, minúsculaLetter, Lowercase
LuLu Letra, maiúsculaLetter, Uppercase
LtLt Letra, títuloLetter, Titlecase
LoLo Letra, outraLetter, Other
LmLm Letra, modificadorLetter, Modifier
MnMn Marca, sem espaçamentoMark, Nonspacing
NdNd Número, dígito decimalNumber, Decimal Digit
PcPc Pontuação, conector.Punctuation, Connector. Essa categoria inclui dez caracteres, o mais comumente usado deles é o LOWLINE (), u+005F.This category includes ten characters, the most commonly used of which is the LOWLINE character (), u+005F.

Se o comportamento compatível com ECMAScript for especificado, \w será equivalente a [a-zA-Z_0-9].If ECMAScript-compliant behavior is specified, \w is equivalent to [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.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

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.Because it matches any word character, the \w language element is often used with a lazy quantifier if a regular expression pattern attempts to match any word character multiple times, followed by a specific word character. Para saber mais, confira Quantificadores.For more information, see Quantifiers.

O exemplo a seguir usa o elemento de linguagem \w para corresponder a caracteres duplicados em uma palavra.The following example uses the \w language element to match duplicate characters in a word. O exemplo define um padrão de expressão regular, (\w)\1, que pode ser interpretado como a seguir.The example defines a regular expression pattern, (\w)\1, which can be interpreted as follows.

ElementoElement DescriçãoDescription
(\w)(\w) Corresponder a um caractere de palavra.Match a word character. Este é o primeiro grupo de captura.This is the first capturing group.
\1\1 Corresponder ao valor da primeira captura.Match the value of the first capture.
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: \WNon-word character: \W

\W corresponde a qualquer caractere que não seja uma palavra.\W matches any non-word character. O elemento de linguagem \W é equivalente à seguinte classe de caracteres:The \W language element is equivalent to the following character class:

[^\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.In other words, it matches any character except for those in the Unicode categories listed in the following table.

CategoriaCategory DescriçãoDescription
LILl Letra, minúsculaLetter, Lowercase
LuLu Letra, maiúsculaLetter, Uppercase
LtLt Letra, títuloLetter, Titlecase
LoLo Letra, outraLetter, Other
LmLm Letra, modificadorLetter, Modifier
MnMn Marca, sem espaçamentoMark, Nonspacing
NdNd Número, dígito decimalNumber, Decimal Digit
PcPc Pontuação, conector.Punctuation, Connector. Essa categoria inclui dez caracteres, o mais comumente usado deles é o LOWLINE (), u+005F.This category includes ten characters, the most commonly used of which is the LOWLINE character (), u+005F.

Se o comportamento compatível com ECMAScript for especificado, \W será equivalente a [^a-zA-Z_0-9].If ECMAScript-compliant behavior is specified, \W is equivalent to [^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.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

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.Because it matches any non-word character, the \W language element is often used with a lazy quantifier if a regular expression pattern attempts to match any non-word character multiple times followed by a specific non-word character. Para saber mais, confira Quantificadores.For more information, see Quantifiers.

O exemplo a seguir ilustra a classe de caracteres \W.The following example illustrates the \W character class. 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.It defines a regular expression pattern, \b(\w+)(\W){1,2}, that matches a word followed by one or two non-word characters, such as white space or punctuation. A expressão regular é interpretada conforme mostrado na tabela a seguir.The regular expression is interpreted as shown in the following table.

ElementoElement DescriçãoDescription
\b\b Começa a correspondência em um limite de palavra.Begin the match at a word boundary.
(\w+)(\w+) Corresponde a um ou mais caracteres de palavra.Match one or more word characters. Este é o primeiro grupo de captura.This is the first capturing group.
(\W){1,2}(\W){1,2} Corresponde a um caractere não pertencente a palavras uma ou duas vezes.Match a non-word character either one or two times. Este é o segundo grupo de captura.This is the second capturing group.
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.Because the Group object for the second capturing group contains only a single captured non-word character, the example retrieves all captured non-word characters from the CaptureCollection object that is returned by the Group.Captures property.

Caractere de espaço em branco: \sWhitespace character: \s

\s corresponde a um caractere de espaço em branco.\s matches any whitespace character. É equivalente às sequências de escape e às categorias de Unicode listadas na tabela a seguir.It is equivalent to the escape sequences and Unicode categories listed in the following table.

CategoriaCategory DescriçãoDescription
\f O caractere de avanço de página, \u000C.The form feed character, \u000C.
\n O caractere de nova linha, \u000A.The newline character, \u000A.
\r O caractere de retorno de carro, \u000D.The carriage return character, \u000D.
\t O caractere de tabulação, \u0009.The tab character, \u0009.
\v O caractere de tabulação vertical, \u000B.The vertical tab character, \u000B.
\x85 A elipse ou o caractere NEXT LINE (NEL) (...), \u0085.The ellipsis or NEXT LINE (NEL) character (…), \u0085.
\p{Z} Corresponde a qualquer caractere separador.Matches any separator character.

Se o comportamento compatível com ECMAScript for especificado, \s será equivalente a [ \f\n\r\t\v].If ECMAScript-compliant behavior is specified, \s is equivalent to [ \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.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

O exemplo a seguir ilustra a classe de caracteres \s.The following example illustrates the \s character class. 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.It defines a regular expression pattern, \b\w+(e)?s(\s|$), that matches a word ending in either "s" or "es" followed by either a white-space character or the end of the input string. A expressão regular é interpretada conforme mostrado na tabela a seguir.The regular expression is interpreted as shown in the following table.

ElementoElement DescriçãoDescription
\b\b Começa a correspondência em um limite de palavra.Begin the match at a word boundary.
\w+\w+ Corresponde a um ou mais caracteres de palavra.Match one or more word characters.
(e)?(e)? Corresponder a um “e” zero ou uma vez.Match an "e" either zero or one time.
ss Corresponder a um “s”.Match an "s".
(\s|$)(\s|$) Corresponder a um caractere de espaço em branco ou ao fim da cadeia de caracteres de entrada.Match either a white-space character or the end of the input string.
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: \SNon-whitespace character: \S

\S corresponde a qualquer caractere que não seja um caractere de espaço em branco.\S matches any non-white-space character. 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.It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. Para saber mais, confira Caractere de espaço em branco: \s.For more information, see White-Space Character: \s.

Se o comportamento compatível com ECMAScript for especificado, \S será equivalente a [^ \f\n\r\t\v].If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \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.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

O exemplo a seguir ilustra o elemento de linguagem \S.The following example illustrates the \S language element. 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.The regular expression pattern \b(\S+)\s? matches strings that are delimited by white-space characters. O segundo elemento no objeto GroupCollection da correspondência contém a cadeia de caracteres correspondida.The second element in the match's GroupCollection object contains the matched string. A expressão regular pode ser interpretada conforme mostrado na tabela a seguir.The regular expression can be interpreted as shown in the following table.

ElementoElement DescriçãoDescription
\b Começa a correspondência em um limite de palavra.Begin the match at a word boundary.
(\S+) Corresponder a um ou mais caracteres diferentes de espaço em branco.Match one or more non-white-space characters. Este é o primeiro grupo de captura.This is the first capturing group.
\s? Corresponder a zero ou a um caractere de espaço em branco.Match zero or one white-space character.
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: \dDecimal digit character: \d

\d corresponde a qualquer dígito decimal.\d matches any decimal digit. É 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.It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets.

Se o comportamento compatível com ECMAScript for especificado, \d será equivalente a [0-9].If ECMAScript-compliant behavior is specified, \d is equivalent to [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.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

O exemplo a seguir ilustra o elemento de linguagem \d.The following example illustrates the \d language element. Ele testa se uma cadeia de caracteres de entrada representa um número de telefone válido nos Estados Unidos e no Canadá.It tests whether an input string represents a valid telephone number in the United States and Canada. O padrão de expressão regular ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ é definido conforme mostrado na tabela a seguir.The regular expression pattern ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ is defined as shown in the following table.

ElementoElement DescriçãoDescription
^ Começar a correspondência no início da cadeia de caracteres de entrada.Begin the match at the beginning of the input string.
\(? Corresponder a zero ou a um caractere "(" literal.Match zero or one literal "(" character.
\d{3} Corresponder a três dígitos decimais.Match three decimal digits.
\)? Corresponder a zero ou a um caractere ")" literal.Match zero or one literal ")" character.
[\s-] Corresponder a um hífen ou a caractere de espaço em branco.Match a hyphen or a white-space character.
(\(?\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.Match an optional opening parenthesis followed by three decimal digits, an optional closing parenthesis, and either a white-space character or a hyphen zero or one time. Este é o primeiro grupo de captura.This is the first capturing group.
\d{3}-\d{4} Corresponder aos três dígitos decimais seguidos por um hífen e mais quatro dígitos decimais.Match three decimal digits followed by a hyphen and four more decimal digits.
$ Corresponder ao final da cadeia de caracteres de entrada.Match the end of the input string.
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: \DNon-digit character: \D

\D corresponde a qualquer caractere que não seja um dígito.\D matches any non-digit character. É equivalente ao padrão de expressão regular \P{Nd}.It is equivalent to the \P{Nd} regular expression pattern.

Se o comportamento compatível com ECMAScript for especificado, \D será equivalente a [^0-9].If ECMAScript-compliant behavior is specified, \D is equivalent to [^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.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

O exemplo a seguir ilustra o elemento de linguagem \D.The following example illustrates the \D language element. 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.It tests whether a string such as a part number consists of the appropriate combination of decimal and non-decimal characters. O padrão de expressão regular ^\D\d{1,5}\D*$ é definido conforme mostrado na tabela a seguir.The regular expression pattern ^\D\d{1,5}\D*$ is defined as shown in the following table.

ElementoElement DescriçãoDescription
^ Começar a correspondência no início da cadeia de caracteres de entrada.Begin the match at the beginning of the input string.
\D Corresponder a um caractere que não seja um dígito.Match a non-digit character.
\d{1,5} Corresponder a um a cinco dígitos decimais.Match from one to five decimal digits.
\D* Corresponder a zero ou a um ou mais caracteres não decimais.Match zero, one, or more non-decimal characters.
$ Corresponder ao final da cadeia de caracteres de entrada.Match the end of the input string.
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 suporteSupported Unicode general categories

O Unicode define as categorias gerais listadas na tabela a seguir.Unicode defines the general categories listed in the following table. 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.For more information, see the "UCD File Format" and "General Category Values" subtopics at the Unicode Character Database.

CategoriaCategory DescriçãoDescription
Lu Letra, maiúsculaLetter, Uppercase
Ll Letra, minúsculaLetter, Lowercase
Lt Letra, títuloLetter, Titlecase
Lm Letra, modificadorLetter, Modifier
Lo Letra, outraLetter, Other
L Todos os caracteres de letras.All letter characters. Isso inclui os caracteres Lu, Ll, Lt, Lm e Lo.This includes the Lu, Ll, Lt, Lm, and Lo characters.
Mn Marca, sem espaçamentoMark, Nonspacing
Mc Marca, combinação de espaçamentoMark, Spacing Combining
Me Marca, delimitadorMark, Enclosing
M Todas as marcas diacríticas.All diacritic marks. Isso inclui as categorias Mn, Mc e Me.This includes the Mn, Mc, and Me categories.
Nd Número, dígito decimalNumber, Decimal Digit
Nl Número, letraNumber, Letter
No Número, outroNumber, Other
N Todos os números.All numbers. Isso inclui as categorias Nd, Nl e No.This includes the Nd, Nl, and No categories.
Pc Pontuação, conectorPunctuation, Connector
Pd Pontuação, traçoPunctuation, Dash
Ps Pontuação, aberturaPunctuation, Open
Pe Pontuação, fechamentoPunctuation, Close
Pi Pontuação, aspas iniciais (podem se comportar como Ps ou Pe, dependendo do uso)Punctuation, Initial quote (may behave like Ps or Pe depending on usage)
Pf Pontuação, aspas finais (podem se comportar como Ps ou Pe, dependendo do uso)Punctuation, Final quote (may behave like Ps or Pe depending on usage)
Po Pontuação, outrosPunctuation, Other
P Todos os caracteres de pontuação.All punctuation characters. Isso inclui as categorias Pc, Pd, Ps, Pe, Pi, Pf e Po.This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories.
Sm Símbolo, matemáticoSymbol, Math
Sc Símbolo, moedaSymbol, Currency
Sk Símbolo, modificadorSymbol, Modifier
So Símbolo, outrosSymbol, Other
S Todos os símbolos.All symbols. Isso inclui as categorias Sm, Sc, Sk e So.This includes the Sm, Sc, Sk, and So categories.
Zs Separador, espaçoSeparator, Space
Zl Separador, linhaSeparator, Line
Zp Separador, parágrafoSeparator, Paragraph
Z Todos os caracteres de separador.All separator characters. Isso inclui as categorias Zs, Zl e Zp.This includes the Zs, Zl, and Zp categories.
Cc Outros, controleOther, Control
Cf Outros, formatoOther, Format
Cs Outros, substitutosOther, Surrogate
Co Outros, uso privadoOther, Private Use
Cn Outros, não atribuído (nenhum caractere tem esta propriedade)Other, Not Assigned (no characters have this property)
C Todos os caracteres de controle.All control characters. Isso inclui as categorias Cc, Cf, Cs, Co e Cn.This includes the Cc, Cf, Cs, Co, and Cn categories.

Você pode determinar a categoria Unicode de qualquer caractere específico ao passar esse caractere para o método GetUnicodeCategory.You can determine the Unicode category of any particular character by passing that character to the GetUnicodeCategory method. 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.The following example uses the GetUnicodeCategory method to determine the category of each element in an array that contains selected Latin characters.

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íveisSupported named blocks

O .NET fornece os blocos nomeados listados na tabela a seguir..NET provides the named blocks listed in the following table. O conjunto de blocos nomeados com suporte baseia-se no Unicode 4.0 e no Perl 5.6.The set of supported named blocks is based on Unicode 4.0 and Perl 5.6. Para uma expressão regular que usa blocos nomeados, consulte a seçãoCategoria Unicode ou bloco Unicode: \p{}.For a regular expression that uses named blocks, see the Unicode category or Unicode block: \p{} section.

Intervalo de ponto de códigoCode point range Nome do blocoBlock name
0000 - 007F0000 - 007F IsBasicLatin
0080 - 00FF0080 - 00FF IsLatin-1Supplement
0100 - 017F0100 - 017F IsLatinExtended-A
0180 - 024F0180 - 024F IsLatinExtended-B
0250 - 02AF0250 - 02AF IsIPAExtensions
02B0 - 02FF02B0 - 02FF IsSpacingModifierLetters
0300 - 036F0300 - 036F IsCombiningDiacriticalMarks
0370 - 03FF0370 - 03FF IsGreek

- ou --or-

IsGreekandCoptic
0400 - 04FF0400 - 04FF IsCyrillic
0500 - 052F0500 - 052F IsCyrillicSupplement
0530 - 058F0530 - 058F IsArmenian
0590 - 05FF0590 - 05FF IsHebrew
0600 - 06FF0600 - 06FF IsArabic
0700 - 074F0700 - 074F IsSyriac
0780 - 07BF0780 - 07BF IsThaana
0900 - 097F0900 - 097F IsDevanagari
0980 - 09FF0980 - 09FF IsBengali
0A00 - 0A7F0A00 - 0A7F IsGurmukhi
0A80 - 0AFF0A80 - 0AFF IsGujarati
0B00 - 0B7F0B00 - 0B7F IsOriya
0B80 - 0BFF0B80 - 0BFF IsTamil
0C00 - 0C7F0C00 - 0C7F IsTelugu
0C80 - 0CFF0C80 - 0CFF IsKannada
0D00 - 0D7F0D00 - 0D7F IsMalayalam
0D80 - 0DFF0D80 - 0DFF IsSinhala
0E00 - 0E7F0E00 - 0E7F IsThai
0E80 - 0EFF0E80 - 0EFF IsLao
0F00 - 0FFF0F00 - 0FFF IsTibetan
1000 - 109F1000 - 109F IsMyanmar
10A0 - 10FF10A0 - 10FF IsGeorgian
1100 - 11FF1100 - 11FF IsHangulJamo
1200 - 137F1200 - 137F IsEthiopic
13A0 - 13FF13A0 - 13FF IsCherokee
1400 - 167F1400 - 167F IsUnifiedCanadianAboriginalSyllabics
1680 - 169F1680 - 169F IsOgham
16A0 - 16FF16A0 - 16FF IsRunic
1700 - 171F1700 - 171F IsTagalog
1720 - 173F1720 - 173F IsHanunoo
1740 - 175F1740 - 175F IsBuhid
1760 - 177F1760 - 177F IsTagbanwa
1780 - 17FF1780 - 17FF IsKhmer
1800 - 18AF1800 - 18AF IsMongolian
1900 - 194F1900 - 194F IsLimbu
1950 - 197F1950 - 197F IsTaiLe
19E0 - 19FF19E0 - 19FF IsKhmerSymbols
1D00 - 1D7F1D00 - 1D7F IsPhoneticExtensions
1E00 - 1EFF1E00 - 1EFF IsLatinExtendedAdditional
1F00 - 1FFF1F00 - 1FFF IsGreekExtended
2000 - 206F2000 - 206F IsGeneralPunctuation
2070 - 209F2070 - 209F IsSuperscriptsandSubscripts
20A0 - 20CF20A0 - 20CF IsCurrencySymbols
20D0 - 20FF20D0 - 20FF IsCombiningDiacriticalMarksforSymbols

- ou --or-

IsCombiningMarksforSymbols
2100 - 214F2100 - 214F IsLetterlikeSymbols
2150 - 218F2150 - 218F IsNumberForms
2190 - 21FF2190 - 21FF IsArrows
2200 - 22FF2200 - 22FF IsMathematicalOperators
2300 - 23FF2300 - 23FF IsMiscellaneousTechnical
2400 - 243F2400 - 243F IsControlPictures
2440 - 245F2440 - 245F IsOpticalCharacterRecognition
2460 - 24FF2460 - 24FF IsEnclosedAlphanumerics
2500 - 257F2500 - 257F IsBoxDrawing
2580 - 259F2580 - 259F IsBlockElements
25A0 - 25FF25A0 - 25FF IsGeometricShapes
2600 - 26FF2600 - 26FF IsMiscellaneousSymbols
2700 - 27BF2700 - 27BF IsDingbats
27C0 - 27EF27C0 - 27EF IsMiscellaneousMathematicalSymbols-A
27F0 - 27FF27F0 - 27FF IsSupplementalArrows-A
2800 - 28FF2800 - 28FF IsBraillePatterns
2900 - 297F2900 - 297F IsSupplementalArrows-B
2980 - 29FF2980 - 29FF IsMiscellaneousMathematicalSymbols-B
2A00 - 2AFF2A00 - 2AFF IsSupplementalMathematicalOperators
2B00 - 2BFF2B00 - 2BFF IsMiscellaneousSymbolsandArrows
2E80 - 2EFF2E80 - 2EFF IsCJKRadicalsSupplement
2F00 - 2FDF2F00 - 2FDF IsKangxiRadicals
2FF0 - 2FFF2FF0 - 2FFF IsIdeographicDescriptionCharacters
3000 - 303F3000 - 303F IsCJKSymbolsandPunctuation
3040 - 309F3040 - 309F IsHiragana
30A0 - 30FF30A0 - 30FF IsKatakana
3100 - 312F3100 - 312F IsBopomofo
3130 - 318F3130 - 318F IsHangulCompatibilityJamo
3190 - 319F3190 - 319F IsKanbun
31A0 - 31BF31A0 - 31BF IsBopomofoExtended
31F0 - 31FF31F0 - 31FF IsKatakanaPhoneticExtensions
3200 - 32FF3200 - 32FF IsEnclosedCJKLettersandMonths
3300 - 33FF3300 - 33FF IsCJKCompatibility
3400 - 4DBF3400 - 4DBF IsCJKUnifiedIdeographsExtensionA
4DC0 - 4DFF4DC0 - 4DFF IsYijingHexagramSymbols
4E00 - 9FFF4E00 - 9FFF IsCJKUnifiedIdeographs
A000 - A48FA000 - A48F IsYiSyllables
A490 - A4CFA490 - A4CF IsYiRadicals
AC00 - D7AFAC00 - D7AF IsHangulSyllables
D800 - DB7FD800 - DB7F IsHighSurrogates
DB80 - DBFFDB80 - DBFF IsHighPrivateUseSurrogates
DC00 - DFFFDC00 - DFFF IsLowSurrogates
E000 - F8FFE000 - F8FF IsPrivateUse ou IsPrivateUseAreaIsPrivateUse or IsPrivateUseArea
F900 - FAFFF900 - FAFF IsCJKCompatibilityIdeographs
FB00 - FB4FFB00 - FB4F IsAlphabeticPresentationForms
FB50 - FDFFFB50 - FDFF IsArabicPresentationForms-A
FE00 - FE0FFE00 - FE0F IsVariationSelectors
FE20 - FE2FFE20 - FE2F IsCombiningHalfMarks
FE30 - FE4FFE30 - FE4F IsCJKCompatibilityForms
FE50 - FE6FFE50 - FE6F IsSmallFormVariants
FE70 - FEFFFE70 - FEFF IsArabicPresentationForms-B
FF00 - FFEFFF00 - FFEF IsHalfwidthandFullwidthForms
FFF0 - FFFFFFF0 - FFFF IsSpecials

Subtração de classes de caractere: [base_group - [excluded_group]]Character class subtraction: [base_group - [excluded_group]]

Uma classe de caracteres define um conjunto de caracteres.A character class defines a set of characters. 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.Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class.

A expressão de subtração de classes de caracteres tem a seguinte forma:A character class subtraction expression has the following form:

[ base_group -[ excluded_group ]][ base_group -[ excluded_group ]]

Os colchetes ([]) e hífen (-) são obrigatórios.The square brackets ([]) and hyphen (-) are mandatory. O base_group é um grupo de caracteres positivos ou um grupo de caracteres negativos.The base_group is a positive character group or a negative character group. 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).The excluded_group component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions).

Por exemplo, suponha que você tenha um grupo base que consiste no intervalo de caracteres de "a" a "z".For example, suppose you have a base group that consists of the character range from "a" through "z". Para definir o conjunto de caracteres que consiste no grupo base, exceto pelo caractere "m", use [a-z-[m]].To define the set of characters that consists of the base group except for the character "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]].To define the set of characters that consists of the base group except for the set of characters "d", "j", and "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]].To define the set of characters that consists of the base group except for the character range from "m" through "p", use [a-z-[m-p]].

Considere a expressão de subtração de classes de caracteres aninhada, [a-z-[d-w-[m-o]]].Consider the nested character class subtraction expression, [a-z-[d-w-[m-o]]]. A expressão é calculada do intervalo de caracteres mais interno para fora.The expression is evaluated from the innermost character range outward. 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".First, the character range from "m" through "o" is subtracted from the character range "d" through "w", which yields the set of characters from "d" through "l" and "p" through "w". Esse conjunto é subtraído do intervalo de caracteres de "a" a "z", o que produz o conjunto de caracteres [abcmnoxyz].That set is then subtracted from the character range from "a" through "z", which yields the set of characters [abcmnoxyz].

Você pode usar qualquer classe de caracteres com a subtração de classes de caracteres.You can use any character class with character class subtraction. 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]].To define the set of characters that consists of all Unicode characters from \u0000 through \uFFFF except white-space characters (\s), the characters in the punctuation general category (\p{P}), the characters in the IsGreek named block (\p{IsGreek}), and the Unicode NEXT LINE control character (\x85), use [\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.Choose character classes for a character class subtraction expression that will yield useful results. 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.Avoid an expression that yields an empty set of characters, which cannot match anything, or an expression that is equivalent to the original base group. 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.For example, the empty set is the result of the expression [\p{IsBasicLatin}-[\x00-\x7F]], which subtracts all characters in the IsBasicLatin character range from the IsBasicLatin general category. Da mesma forma, o grupo base original é o resultado da expressão [a-z-[0-9]].Similarly, the original base group is the result of the expression [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".This is because the base group, which is the character range of letters from "a" through "z", does not contain any characters in the excluded group, which is the character range of decimal digits from "0" through "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.The following example defines a regular expression, ^[0-9-[2468]]+$, that matches zero and odd digits in an input string. A expressão regular é interpretada conforme mostrado na tabela a seguir.The regular expression is interpreted as shown in the following table.

ElementoElement DescriçãoDescription
^ Começar a correspondência no início da cadeia de caracteres de entrada.Begin the match at the start of the input string.
[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.Match one or more occurrences of any character from 0 to 9 except for 2, 4, 6, and 8. Em outras palavras, corresponder a uma ou mais ocorrências de zero ou de um dígito ímpar.In other words, match one or more occurrences of zero or an odd digit.
$ Finalizar a correspondência no final da cadeia de caracteres de entrada.End the match at the end of the input string.
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émSee also