Partilhar via

Classes de Caracteres

  • Artigo

Uma classe de caracteres define um conjunto de caracteres, qualquer um dos quais pode ocorrer em uma seqüência de caracteres de entrada para uma correspondência seja bem-sucedida. A linguagem de expressão regular na.NET Framework oferece suporte as classes de caracteres a seguir:

  • Grupos de caracteres positivo. Um caractere na seqüência de entrada deve corresponder a um de um conjunto de caracteres especificado. Para obter mais informações, consulte Positivo grupo de caracteres.

  • Grupos de caracteres negativos. Um caractere na seqüência 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 caractere. O . (ponto ou período) o caractere em uma expressão regular é um caractere curinga que corresponde a qualquer caractere exceto \n. Para obter mais informações, consulte Qualquer caractere.

  • Uma categoria geral do Unicode ou um bloco nomeado. Um caractere na seqüência de entrada deve ser um membro de uma determinada categoria Unicode ou deve estar dentro de um contíguo intervalo de caracteres Unicode para uma correspondência seja bem-sucedida. Para obter mais informações, consulte categoria Unicode ou bloco de Unicode.

  • Uma categoria de Unicode geral negativa ou um bloco de nomeado. Um caractere na seqüência de entrada não deve ser um membro de uma determinada categoria Unicode ou não deve ficar dentro de um contíguo intervalo de caracteres Unicode para uma correspondência seja bem-sucedida. Para obter mais informações, consulte categoria de Unicode negativo ou bloco de Unicode.

  • Um caractere de palavra. Um caractere na seqüência de entrada pode pertencer a qualquer categoria Unicode que são apropriada para caracteres de palavras. Para obter mais informações, consulte O caractere de palavra.

  • Não-alfabético. Um caractere na seqüência de entrada pode pertencer a qualquer categoria Unicode que não é um caractere de palavra. Para obter mais informações, consulte Não-alfabético.

  • Um caractere de espaço em branco. Um caractere na seqüência de entrada pode ser qualquer caractere separador de Unicode, bem como qualquer um de um número de caracteres de controle. Para obter mais informações, consulte O caractere de espaço em branco.

  • Um caractere que não seja espaço em branco. Um caractere na seqüência de entrada pode ser qualquer caractere que não é um caractere de espaço em branco. Para obter mais informações, consulte O caractere de espaço em branco-não.

  • Um dígito decimal. Um caractere na seqüência de entrada pode ser qualquer um de um número de caracteres classificados como dígitos de Unicode decimais. Para obter mais informações, consulte O caractere de dígito Decimal.

  • Um dígito decimal com ponto. Um caractere na seqüência de entrada pode ser algo diferente de um dígito decimal do Unicode. Para obter mais informações, consulte O caractere de dígito Decimal.

O .NET Framework suporta classe caractere subtração de expressões, que permite a você definir um conjunto de caracteres como resultado de exclusão de uma classe de caractere de outra classe de caractere. Para obter mais informações, consulte Classe de Caractere Subtração .

Grupo de caracteres positivo: [ ]

Um grupo de caracteres positivo especifica uma lista de caracteres, qualquer um dos quais pode aparecer em uma seqüência de caracteres de entrada para uma correspondência ocorrer. Esta lista de caracteres pode ser especificada individualmente, como um intervalo ou ambos.

A sintaxe para especificar uma lista de caracteres individuais é o seguinte:

character_group

onde character_group é uma lista de caracteres individuais que podem aparecer na seqüência de entrada para 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 é o seguinte:

[firstCharacter-lastCharacter]

onde firstCharacter é o caractere que inicia o intervalo e lastCharacter é o caractere que finaliza o intervalo. Um intervalo de caracteres é uma série contígua de caracteres definidos, especificando o primeiro caractere na série, um hífen (-) , e o último caractere na série. Dois caracteres são contíguos se eles tiverem pontos de código Unicode adjacentes.

Alguns padrões comuns de expressão regular que contêm classes de caractere positivos são listados na tabela a seguir.

Padrão

Descrição

[aeiou]

Corresponde todas as vogais.

[\p{P}\d]

Corresponde a todos os caracteres de dígitos decimais e pontuação.

[\s\p{P}]

Corresponde a todos os espaço em branco e pontuação.

O exemplo a seguir define um grupo de caracteres positivo que contém os caracteres "a" e "e" para que a seqüência de caracteres de entrada deve conter as palavras "galo" ou "gato" seguido de outra palavra para uma correspondência ocorrer.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "gr[ae]y\s\S+?[\s|\p{P}]"
      Dim input As String = "The gray wolf jumped over the grey wall."
      Dim matches As MatchCollection = Regex.Matches(input, pattern)
      For Each match As Match In matches
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       gray wolf
'       grey wall.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"gr[ae]y\s\S+?[\s|\p{P}]";
      string input = "The gray wolf jumped over the grey wall.";
      MatchCollection matches = Regex.Matches(input, pattern);
      foreach (Match match in matches)
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       gray wolf
//       grey wall.

A expressão regular gr[ae]y\s\S+?[\s|\p{P}] é definido da seguinte maneira:

Padrão

Descrição

gr

Corresponde os "gr" de caracteres literais.

[ae]

Uma correspondência um "a" ou "e".

y\s

Corresponder ao caractere literal "y" seguido por um caractere de espaço em branco.

\S+?

Corresponde a um ou mais caracteres não-espaço em branco, mas a menor quantidade possível.

[\s|\p{P}]

Corresponde a um caractere de espaço em branco ou uma marca de pontuação.

O exemplo a seguir corresponde a palavras que comecem com qualquer letra maiúscula. Ele usa a subexpressão [A-Z] para representar o intervalo de letras em maiúsculas de à z

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[A-Z]\w*\b"
      Dim input As String = "A city Albany Zulu maritime Marseilles"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[A-Z]\w*\b";
      string input = "A city Albany Zulu maritime Marseilles";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       A
//       Albany
//       Zulu
//       Marseilles

A expressão regular \b[A-Z]\w*\b é definido como mostrado na tabela a seguir.

Padrão

Descrição

\b

Iniciar em um limite de palavra.

[A-Z]

Corresponde a qualquer caractere de maiúsculas de À Z.

\w*

Corresponde a zero ou mais caracteres do word.

\b

Corresponde a um limite de palavra.

Voltar ao início

Grupo de caracteres de negativo: [^]

Um grupo de caracteres negativos Especifica uma lista de caracteres que não devem aparecer em uma seqüência de caracteres de entrada para uma correspondência ocorrer. A lista de caracteres pode ser especificada individualmente, como um intervalo ou ambos.

A sintaxe para especificar uma lista de caracteres individuais é o seguinte:

^ character_group

onde character_group é uma lista dos caracteres individuais que não pode aparecer na seqüência de entrada para 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 é o seguinte:

^firstCharacter-lastCharacter

onde firstCharacter é o caractere que inicia o intervalo e lastCharacter é o caractere que finaliza o intervalo. Um intervalo de caracteres é uma série contígua de caracteres definidos, especificando o primeiro caractere na série, um hífen (-) , e o último caractere na série. Dois caracteres são contíguos se eles tiverem pontos de código Unicode adjacentes.

Dois ou mais intervalos de caracteres podem ser concatenados. Por exemplo, para especificar o intervalo de dígitos decimais de "0" por meio de "9", o intervalo de letras em minúsculas do "a" por meio de "f" e o intervalo de letras maiúsculas de "A" por meio de "F", use [0-9a-fA-F].

O caractere à esquerda de intercalação (^) em um caractere negativo o grupo é obrigatório e indica o grupo de caracteres é um grupo de caracteres negativos em vez de um grupo de caracteres positivo.

Observação importanteImportante

Um grupo de caracteres negativos em um padrão de expressão regular maior não é uma declaração de largura igual a zero.Ou seja, depois de avaliar o grupo de caracteres negativos, o mecanismo de expressão regular avança um caractere na seqüência de entrada.

Alguns padrões comuns de expressão regular que contêm grupos de caracteres negativos são listados na tabela a seguir.

Padrão

Descrição

[^aeiou]

Corresponde a todos os caracteres, exceto as vogais.

[^\p{P}\d]

Corresponde a todos os caracteres, exceto os caracteres de dígitos decimais e pontuação.

O exemplo a seguir corresponde a qualquer palavra que comece com os caracteres "th" e não é seguido por "o".

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\bth[^o]\w+\b"
      Dim input As String = "thought thing though them through thus " + _
                            "thorough this"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       thing
'       them
'       through
'       thus
'       this

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bth[^o]\w+\b";
      string input = "thought thing though them through thus thorough this";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       thing
//       them
//       through
//       thus
//       this

A expressão regular \bth[^o]\w+\b é definido como mostrado na tabela a seguir.

Padrão

Descrição

\b

Iniciar em um limite de palavra.

th

Corresponde os "th" de caracteres literais.

[^o]

Corresponde a qualquer caractere que não seja "o".

\w+

Corresponde a um ou mais caracteres do word.

\b

Terminar em um limite de palavra.

Voltar ao início

Qualquer caractere: .

O caractere ponto (.) corresponde a qualquer caractere exceto \n (o caractere de nova linha, \u000A) com as seguintes dois qualificações:

  • Se um padrão de expressão regular é modificado pela RegexOptions.Singleline opção, ou se a parte do padrão que contém o . a classe de caractere é modificada pelo s opção, . corresponde a qualquer caractere. Para obter mais informações, consulte Opções de expressões regulares.

    O exemplo a seguir ilustra o comportamento diferente de . classe de caracteres, por padrão e com o RegexOptions.Singleline opção. A expressão regular ^.+ começa no início da seqüência de caracteres e corresponde a cada caractere. 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 ele não corresponde a \n. Porque o RegexOptions.Singleline opção interpreta a seqüência de entrada inteira como uma única linha, corresponde a cada caractere na seqüência de entrada, incluindo \n.

    Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^.+"
      Dim input As String = "This is one line and" + vbCrLf + "this is the second."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(Regex.Escape(match.Value))
      Next
      Console.WriteLine()
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.SingleLine)
         Console.WriteLine(Regex.Escape(match.Value))
      Next
   End Sub
End Module
' The example displays the following output:
'       This\ is\ one\ line\ and\r
'       
'       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

    using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "^.+";
      string input = "This is one line and" + Environment.NewLine + "this is the second.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(Regex.Escape(match.Value));

      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline))
         Console.WriteLine(Regex.Escape(match.Value));
   }
}
// The example displays the following output:
//       This\ is\ one\ line\ and\r
//       
//       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

Observação

Porque ele coincide com qualquer caractere, exceto \n, o . a classe de caractere também corresponde a \r (o caractere de retorno de carro, \u000D).

  • Em um grupo de caracteres positivo ou negativo, um período é tratado como um caractere literal do período e não como uma classe de caracteres. Para obter mais informações, consulte Positivo grupo de caracteres 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 ponto (.) como uma classe de caracteres e um membro de um grupo de caracteres positivo. A expressão regular \b.*[.?!;:](\s|\z) começa em um limite de palavra, corresponde a qualquer caractere até encontrar um dos quatro marcas de pontuação, incluindo um período e corresponde a um caractere de espaço em branco ou o final da seqüência de caracteres.

    Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As STring = "\b.*[.?!;:](\s|\z)"
      Dim input As String = "this. what: is? go, thing."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next   
   End Sub
End Module
' The example displays the following output:
'       this. what: is? go, thing.

    using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b.*[.?!;:](\s|\z)";
      string input = "this. what: is? go, thing.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       this. what: is? go, thing.

Observação

Porque ele coincide com qualquer caractere, o . o elemento de linguagem é freqüentemente usado com um quantificador lazy se um padrão de expressão regular tenta corresponder a qualquer caractere várias vezes.Para obter mais informações, consulte Quantificadores.

Voltar ao início

Categoria Unicode ou bloco de Unicode: {} \p

O padrão Unicode atribui uma categoria geral de cada caractere. Por exemplo, um caractere específico pode ser uma letra maiúscula (representado pela Lu categoria), um dígito decimal (o Nd categoria), um símbolo matemático (o Sm categoria), ou um separador de parágrafo (o Zl categoria). Os conjuntos de caracteres específicos no padrão Unicode também ocupam um intervalo específico ou um bloco de pontos de código consecutivos. Por exemplo, o conjunto básico de caracteres latinos é encontrado de \u0000 por meio de \u007F, enquanto o conjunto de caracteres árabe foi encontrado em \u0600 por meio de \u06FF.

A construção de expressão regular

\p{name}

corresponde a qualquer caractere que pertence a uma categoria geral do Unicode ou bloco nomeado, onde nome é a abreviação de categoria ou o nome do bloco nomeado. Para obter uma lista de abreviações de categoria, consulte o Suporte para categorias de Unicode geral seção mais adiante neste tópico. Para obter uma lista de blocos nomeados, consulte o Suporte para blocos de chamada seção mais adiante neste tópico.

O exemplo a seguir usa a \p{nome} construção para corresponder tanto uma categoria geral do Unicode (nesse caso, o Pd, ou pontuação, a categoria de traço) e um bloco nomeado (a IsGreek e IsBasicLatin chamado blocos).

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+"
      Dim input As String = "Κατα Μαθθαίον - The Gospel of Matthew"

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

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+";
      string input = "Κατα Μαθθαίον - The Gospel of Matthew";

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

A expressão regular \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ é definido como mostrado na tabela a seguir.

Padrão

Descrição

\b

Iniciar em um limite de palavra.

\p{IsGreek}+

Corresponde a um ou mais caracteres gregos.

(\s)?

Corresponde a zero ou um caractere de espaço em branco.

(\p{IsGreek}+(\s)?)+

Correspondência do padrão de um ou mais caracteres gregos, seguido de zero ou um espaço em branco caracteres de uma ou mais vezes.

\p{Pd}

Corresponde a uma pontuação, caracteres de traço.

\s

Corresponde a um caractere de espaço em branco.

\p{IsBasicLatin}+

Corresponde a um ou mais caracteres latinos básicos.

(\s)?

Corresponde a zero ou um caractere de espaço em branco.

(\p{IsBasicLatin}+(\s)?)+

Correspondência do padrão de um ou mais básicos caracteres latinos seguido de zero ou um espaço em branco caracteres de uma ou mais vezes.

Voltar ao início

Negativo categoria Unicode ou bloco de Unicode: {} \P

O padrão Unicode atribui uma categoria geral de cada caractere. Por exemplo, um caractere específico pode ser uma letra maiúscula (representado pela Lu categoria), um dígito decimal (o Nd categoria), um símbolo matemático (o Sm categoria), ou um separador de parágrafo (o Zl categoria). Os conjuntos de caracteres específicos no padrão Unicode também ocupam um intervalo específico ou um bloco de pontos de código consecutivos. Por exemplo, o conjunto básico de caracteres latinos é encontrado de \u0000 por meio de \u007F, enquanto o conjunto de caracteres árabe foi encontrado em \u0600 por meio de \u06FF.

A construção de expressão regular

\P{name}

corresponde a qualquer caractere que não pertence a uma categoria geral do Unicode ou bloco nomeado, onde nome é a abreviação de categoria ou o nome do bloco nomeado. Para obter uma lista de abreviações de categoria, consulte o Suporte para categorias de Unicode geral seção mais adiante neste tópico. Para obter uma lista de blocos nomeados, consulte o Suporte para blocos de chamada seção mais adiante neste tópico.

O exemplo a seguir usa a \P{nome} a construção de remover quaisquer símbolos de moeda (nesse caso, o Sc, ou símbolo, a categoria de moeda) de seqüências de caracteres numéricos.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\P{Sc})+"

      Dim values() As String = { "$164,091.78", "£1,073,142.68", "73¢", "€120"}
      For Each value As String In values
         Console.WriteLine(Regex.Match(value, pattern).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       164,091.78
'       1,073,142.68
'       73
'       120

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\P{Sc})+";

      string[] values = { "$164,091.78", "£1,073,142.68", "73¢", "€120" };
      foreach (string value in values)
         Console.WriteLine(Regex.Match(value, pattern).Value);
   }
}
// The example displays the following output:
//       164,091.78
//       1,073,142.68
//       73
//       120

O padrão de expressão regular (\P{Sc})+ corresponde a um ou mais caracteres que são símbolos de moeda; Ele efetivamente retira qualquer símbolo de moeda da seqüência de resultado.

Voltar ao início

Caractere de palavra: \w

\wcorresponde a qualquer caractere. Um caractere de palavra é um membro de qualquer uma das categorias Unicode listadas na tabela a seguir.

<strong>Categoria</strong>

Descrição

Ll

Letra, Minúsculas

Lu

Letra, Maiúsculas

Lt

Letra, Título

Lo

Letra, Outro

Lm

Letra, Modificador

Nd

Número, Dígito Decimal

PC

Pontuação, conector. Esta categoria inclui dez caracteres, o mais comumente usado é o caractere (_), u + 005F LOWLINE.

Se for especificado o comportamento compatível com ECMAScript, \w é equivalente a [a-zA-Z_0-9]. Para obter informações sobre expressões regulares do ECMAScript, consulte o "comportamento de correspondência da ECMAScript" seção Opções de expressões regulares.

Observação

Porque ele coincide com qualquer caractere de palavra, o \w o elemento de linguagem é freqüentemente usado com um quantificador lazy 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ífica.Para obter mais informações, consulte Quantificadores.

O exemplo a seguir usa a \w o elemento de linguagem para corresponder a caracteres duplicados no word. O exemplo define um padrão de expressão regular, (\w)\1, que podem ser interpretados como segue:

Elemento

Descrição

(\w)

Corresponde a um caractere de palavra. Este é o primeiro grupo de capturando.

\1

Corresponde ao valor da primeira captura.

 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\w)\1"
      Dim words() As String = { "trellis", "seer", "latter", "summer", _
                                "hoarse", "lesser", "aardvark", "stunned" }
      For Each word As String In words
         Dim match As Match = Regex.Match(word, pattern)
         If match.Success Then
            Console.WriteLine("'{0}' found in '{1}' at position {2}.", _
                              match.Value, word, match.Index)
         Else
            Console.WriteLine("No double characters in '{0}'.", word)
         End If
      Next                                                  
   End Sub
End Module
' The example displays the following output:
'       'll' found in 'trellis' at position 3.
'       'ee' found in 'seer' at position 1.
'       'tt' found in 'latter' at position 2.
'       'mm' found in 'summer' at position 2.
'       No double characters in 'hoarse'.
'       'ss' found in 'lesser' at position 2.
'       'aa' found in 'aardvark' at position 0.
'       'nn' found in 'stunned' at position 3.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w)\1";
      string[] words = { "trellis", "seer", "latter", "summer", 
                         "hoarse", "lesser", "aardvark", "stunned" };
      foreach (string word in words)
      {
         Match match = Regex.Match(word, pattern);
         if (match.Success)
            Console.WriteLine("'{0}' found in '{1}' at position {2}.", 
                              match.Value, word, match.Index);
         else
            Console.WriteLine("No double characters in '{0}'.", word);
      }                                                  
   }
}
// The example displays the following output:
//       'll' found in 'trellis' at position 3.
//       'ee' found in 'seer' at position 1.
//       'tt' found in 'latter' at position 2.
//       'mm' found in 'summer' at position 2.
//       No double characters in 'hoarse'.
//       'ss' found in 'lesser' at position 2.
//       'aa' found in 'aardvark' at position 0.
//       'nn' found in 'stunned' at position 3.

Voltar ao início

Caractere não-Word: \W

\Wcorresponde a qualquer caractere não-word. O elemento de linguagem \W é equivalente a classe de caracteres a seguir:

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

Em outras palavras, corresponde a qualquer caractere exceto aqueles listados na tabela a seguir.

<strong>Categoria</strong>

Descrição

Ll

Letra, Minúsculas

Lu

Letra, Maiúsculas

Lt

Letra, Título

Lo

Letra, Outro

Lm

Letra, Modificador

Nd

Número, Dígito Decimal

PC

Pontuação, conector. Esta categoria inclui dez caracteres, o mais comumente usado é o caractere (_), u + 005F LOWLINE.

Se for especificado o comportamento compatível com ECMAScript, \W é equivalente a [^a-zA-Z_0-9]. Para obter informações sobre expressões regulares do ECMAScript, consulte o "comportamento de correspondência da ECMAScript" seção Opções de expressões regulares.

Observação

Porque ele coincide com qualquer caractere que não word, o \W o elemento de linguagem é freqüentemente usado com um quantificador lazy se um padrão de expressão regular tenta corresponder a qualquer caractere não-word várias vezes seguido por um caractere não-word específicos.Para obter mais informações, consulte Quantificadores.

O exemplo a seguir ilustra o \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 mais caracteres não word, como espaço em branco ou pontuação. A expressão regular é interpretada como mostrado na tabela a seguir.

Elemento

Descrição

\b

Começa a correspondência de um limite de palavra.

(\w+)

Corresponde a um ou mais caracteres do word. Este é o primeiro grupo de capturando.

(\w){1,2}

Corresponde a um caractere não-word uma ou duas vezes. Este é o segundo grupo de capturando.

 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\w+)(\W){1,2}"
      Dim input As String = "The old, grey mare slowly walked across the narrow, green pasture."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
         Console.Write("   Non-word character(s):")
         Dim captures As CaptureCollection = match.Groups(2).Captures
         For ctr As Integer = 0 To captures.Count - 1
             Console.Write("'{0}' (\u{1}){2}", captures(ctr).Value, _
                           Convert.ToUInt16(captures(ctr).Value.Chars(0)).ToString("X4"), _
                           If(ctr < captures.Count - 1, ", ", ""))
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'       The
'          Non-word character(s):' ' (\u0020)
'       old,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       grey
'          Non-word character(s):' ' (\u0020)
'       mare
'          Non-word character(s):' ' (\u0020)
'       slowly
'          Non-word character(s):' ' (\u0020)
'       walked
'          Non-word character(s):' ' (\u0020)
'       across
'          Non-word character(s):' ' (\u0020)
'       the
'          Non-word character(s):' ' (\u0020)
'       narrow,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       green
'          Non-word character(s):' ' (\u0020)
'       pasture.
'          Non-word character(s):'.' (\u002E)

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)(\W){1,2}";
      string input = "The old, grey mare slowly walked across the narrow, green pasture.";
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         Console.Write("   Non-word character(s):");
         CaptureCollection captures = match.Groups[2].Captures;
         for (int ctr = 0; ctr < captures.Count; ctr++)
             Console.Write(@"'{0}' (\u{1}){2}", captures[ctr].Value, 
                           Convert.ToUInt16(captures[ctr].Value[0]).ToString("X4"), 
                           ctr < captures.Count - 1 ? ", " : "");
         Console.WriteLine();
      }   
   }
}
// The example displays the following output:
//       The
//          Non-word character(s):' ' (\u0020)
//       old,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       grey
//          Non-word character(s):' ' (\u0020)
//       mare
//          Non-word character(s):' ' (\u0020)
//       slowly
//          Non-word character(s):' ' (\u0020)
//       walked
//          Non-word character(s):' ' (\u0020)
//       across
//          Non-word character(s):' ' (\u0020)
//       the
//          Non-word character(s):' ' (\u0020)
//       narrow,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       green
//          Non-word character(s):' ' (\u0020)
//       pasture.
//          Non-word character(s):'.' (\u002E)

Porque o Group objeto para o segundo grupo de capturando contém somente um único capturados não-alfabético, o exemplo recupera capturados todos os caracteres não-word o CaptureCollection o objeto retornado pelo Group.Captures propriedade.

Voltar ao início

Caractere de espaço em branco: \s

\scorresponde a qualquer caractere de espaço em branco. É equivalente à seqüências de escape e categorias de Unicode, listadas na tabela a seguir.

<strong>Categoria</strong>

Descrição

\f

O caractere de avanço de página, \u000C.

\n

O caractere de nova linha, \u000A.

\r

O caractere de retorno de carro, \u000D.

\t

O caractere de tabulação, \u0009.

\v

O caractere de tabulação vertical, \u000B.

\x85

Reticências ou caractere da próxima linha (NEL) (…), \u0085.

\p{Z}

Corresponde a qualquer caractere separador.

Se for especificado o comportamento compatível com ECMAScript, \s é equivalente a [\f\n\r\t\v]. Para obter informações sobre expressões regulares do ECMAScript, consulte o "comportamento de correspondência da ECMAScript" seção Opções de expressões regulares.

O exemplo a seguir ilustra o \s classe de caractere. Ele define um padrão de expressão regular, \b\w+(e)*s(\s|$), que corresponde a uma palavra que terminam em "s" ou "es" seguido por um caractere de espaço em branco ou o final da seqüência de entrada. A expressão regular é interpretada como mostrado na tabela a seguir.

Elemento

Descrição

\b

Começa a correspondência de um limite de palavra.

rebuscado

Corresponde a um ou mais caracteres do word.

(e) *

Corresponde a um "e" hora de zero ou um.

s

Corresponde ao "s".

(\s|$)

Corresponde a um caractere de espaço em branco ou o final da seqüência de entrada.

 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+(e)*s(\s|$)"
      Dim input As String = "matches stores stops leave leaves"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)      
      Next
   End Sub
End Module
' The example displays the following output:
'       matches
'       stores
'       stops
'       leaves

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+(e)*s(\s|$)";
      string input = "matches stores stops leave leaves";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       matches
//       stores
//       stops
//       leaves

Voltar ao início

Caractere que não seja espaço em branco: \S

\Scorresponde a qualquer caractere que não seja espaço em branco. É equivalente a [^\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 \s, que corresponde a caracteres de espaço em branco. Para obter mais informações, consulte o caractere de espaço em branco: \s.

Se for especificado o comportamento compatível com ECMAScript, \S é equivalente a [^ \f\n\r\t\v]. Para obter informações sobre expressões regulares do ECMAScript, consulte o "comportamento de correspondência da ECMAScript" seção Opções de expressões regulares.

O exemplo a seguir ilustra o \S elemento de linguagem. O padrão de expressão regular \b(\S+)\s* corresponde a strings que são delimitados por caracteres de espaço em branco. O segundo elemento na correspondência GroupCollection objeto contém a seqüência de caracteres correspondentes. A expressão regular pode ser interpretada como mostrado na tabela a seguir.

Elemento

Descrição

\b

Começa a correspondência de um limite de palavra.

(\S+)

Corresponde a um ou mais caracteres não-espaço em branco. Este é o primeiro grupo de capturando.

\s*

Corresponde a zero ou um caractere de espaço em branco.

 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\S+)\s*"
      Dim input As String = "This is the first sentence of the first paragraph. " + _
                            "This is the second sentence." + vbCrLf + _
                            "This is the only sentence of the second paragraph."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Groups(1))
      Next
   End Sub
End Module
' The example displays the following output:
'    This
'    is
'    the
'    first
'    sentence
'    of
'    the
'    first
'    paragraph.
'    This
'    is
'    the
'    second
'    sentence.
'    This
'    is
'    the
'    only
'    sentence
'    of
'    the
'    second
'    paragraph.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\S+)\s*";
      string input = "This is the first sentence of the first paragraph. " + 
                            "This is the second sentence.\n" + 
                            "This is the only sentence of the second paragraph.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Groups[1]);
   }
}
// The example displays the following output:
//    This
//    is
//    the
//    first
//    sentence
//    of
//    the
//    first
//    paragraph.
//    This
//    is
//    the
//    second
//    sentence.
//    This
//    is
//    the
//    only
//    sentence
//    of
//    the
//    second
//    paragraph.

Voltar ao início

Caractere de dígito decimal: \d

\dcorresponde a qualquer dígito decimal. Ela é equivalente a \p{Nd} padrão de expressão regular, que inclui os padrão dígitos decimais 0-9, bem como os dígitos decimais de um número de outros conjuntos de caracteres.

Se for especificado o comportamento compatível com ECMAScript, \d é equivalente a [0-9]. Para obter informações sobre expressões regulares do ECMAScript, consulte o "comportamento de correspondência da ECMAScript" seção Opções de expressões regulares.

O exemplo a seguir ilustra o \d elemento de linguagem. Ele testa se uma seqüência de caracteres de entrada representa um número de telefone válido nos Estados Unidos e Canadá. O padrão de expressão regular ^(\(*\d{3}\)*[\s-])*\d{3}-\d{4}$ é definido como mostrado na tabela a seguir.

Elemento

Descrição

^

Começa a correspondência no início da seqüência de entrada.

\(*

Corresponde a zero ou um literal "(" caractere.

\d{3}

Coincide com três dígitos decimais.

\)*

Corresponde a zero ou um literal de ")" caractere.

[\s-]

Coincide com um hífen ou um caractere de espaço em branco.

(\(*\d{3}\)*[\s-])*

Coincide com um parêntese de abertura opcional seguido de três dígitos, um parêntese de fechamento opcional e um caractere de espaço em branco ou uma hora de hífen zero ou um. Este é o primeiro grupo de capturando.

\d{3}=\d{4}

Coincide com três dígitos decimais, seguidos por um hífen e quatro mais dígitos decimais.

$

Corresponde ao final da seqüência de entrada.

 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^(\(*\d{3}\)*[\s-])*\d{3}-\d{4}$"
      Dim inputs() As String = { "111 111-1111", "222-2222", "222 333-444", _
                                 "(212) 111-1111", "111-AB1-1111", _
                                 "212-111-1111", "01 999-9999" }

      For Each input As String In inputs
         If Regex.IsMatch(input, pattern) Then 
            Console.WriteLine(input + ": matched")
         Else
            Console.WriteLine(input + ": match failed")
         End If   
      Next
   End Sub
End Module
' The example displays the following output:
'       111 111-1111: matched
'       222-2222: matched
'       222 333-444: match failed
'       (212) 111-1111: matched
'       111-AB1-1111: match failed
'       212-111-1111: matched
'       01 999-9999: match failed

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^(\(*\d{3}\)*[\s-])*\d{3}-\d{4}$";
      string[] inputs = { "111 111-1111", "222-2222", "222 333-444", 
                          "(212) 111-1111", "111-AB1-1111", 
                          "212-111-1111", "01 999-9999" };

      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern)) 
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       111 111-1111: matched
//       222-2222: matched
//       222 333-444: match failed
//       (212) 111-1111: matched
//       111-AB1-1111: match failed
//       212-111-1111: matched
//       01 999-9999: match failed

Voltar ao início

Caractere não dígito: \D

\Dcorresponde a qualquer caractere não dígito. Ela é equivalente a \p{Nd} padrão de expressão regular.

Se for especificado o comportamento compatível com ECMAScript, \D é equivalente a [^0-9]. Para obter informações sobre expressões regulares do ECMAScript, consulte o "comportamento de correspondência da ECMAScript" seção Opções de expressões regulares.

O exemplo a seguir ilustra o elemento de linguagem \D. Ele testa se consiste em uma seqüência de caracteres como, por exemplo, um número de peça a combinação adequada de caracteres decimais e não decimais. O padrão de expressão regular ^\D\d{1,5}\D*$ é definido como mostrado na tabela a seguir.

Elemento

Descrição

^

Começa a correspondência no início da seqüência de entrada.

\D

Corresponde a um caractere não dígito.

\d{1,5}

Corresponde de um a cinco dígitos decimais.

\D*

Corresponde a zero ou um caractere de decimal com ponto.

$

Corresponde ao final da seqüência de entrada.

 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^\D\d{1,5}\D*$" 
      Dim inputs() As String = { "A1039C", "AA0001", "C18A", "Y938518" } 

      For Each input As String In inputs
         If Regex.IsMatch(input, pattern) Then
            Console.WriteLine(input + ": matched")
         Else
            Console.WriteLine(input + ": match failed")
         End If   
      Next
   End Sub
End Module
' The example displays the following output:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^\D\d{1,5}\D*$"; 
      string[] inputs = { "A1039C", "AA0001", "C18A", "Y938518" }; 

      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern))
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       A1039C: matched
//       AA0001: match failed
//       C18A: matched
//       Y938518: match failed

Voltar ao início

Categorias Suportadas Unicode gerais

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 Categoria Geral " no Banco de Dados Caractere Unicode .

<strong>Categoria</strong>

Descrição

Lu

Letra, Maiúsculas

Ll

Letra, Minúsculas

Lt

Letra, Título

Lm

Letra, Modificador

Lo

Letra, Outro

L

Todos os caracteres de letra. Isso inclui o Lu, Ll, Lt, Lm, e Lo caracteres.

Mn

Marcar, Não espaçado

Mc

Marca, Espaçamento Combinando

Me

Marcar, Confinar

M

Todas as marcas diacríticas. Isso inclui o Mn, Mc, e 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, Nl, e No categorias.

Pc

Pontuação, Conectores

Pd

Pontuação, Tracejado

Ps

Pontuação, Abrir

Pe

Pontuação, Fechar

Pi

Pontuação, Aspas Iniciais (talvez se comportem como Ps ou Pe, dependendo do uso)

Pf

Pontuação, Aspas Finais (talvez se comportem como Ps ou Pe, dependendo do uso)

Po

Pontuação, Outros

P

Todos os caracteres de pontuação. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories.

Sm

Símbolo, Matemática

Sc

Símbolo, Moeda

Sk

Símbolo, Modificador

So

Símbolo, Outros

S

Todos os símbolos. Isso inclui o Sm, Sc, Sk, e So categorias.

Zs

Separador, Espaço

Zl

Separador, Linha

Zp

Separador, Parágrafo

Z

Todos os caracteres de separação. Isso inclui o Zs, Zl, e Zp categorias.

Cc

Outro, Controle

Cf

Outro, Formatar

Cs

Outro, Substituir

Co

Outros, uso Particular

Cn

Outros, Não Atribuídos (nenhum caractere têm esta propriedade)

C

Todos os caracteres de controle. Isso inclui o Cc, Cf, Cs, Co, e Cn categorias.

Você pode determinar a categoria Unicode de qualquer caractere particular, passando esse caractere para a GetUnicodeCategory método. O exemplo a seguir usa a GetUnicodeCategory método para determinar a categoria de cada elemento em uma matriz que contém caracteres latina selecionada.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim chars() As Char = { "a"c, "X"c, "8"c, ","c, " "c, ChrW(9), "!"c }

      For Each ch As Char In chars
         Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()), _
                           Char.GetUnicodeCategory(ch))
      Next         
   End Sub
End Module
' The example displays the following output:
'       'a': LowercaseLetter
'       'X': UppercaseLetter
'       '8': DecimalDigitNumber
'       ',': OtherPunctuation
'       '\ ': SpaceSeparator
'       '\t': Control
'       '!': OtherPunctuation

using System;
using System.Text.RegularExpressions;

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

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

Voltar ao início

Blocos Nomeados Suportados

A .NET Framework fornece os blocos nomeados listados na tabela a seguir. O conjunto de blocos nomeados suportados é baseado na Unicode 4.0 e Perl 5.6.

Intervalo de ponto de código

Nome do bloco

0000 - 007F

IsBasicLatin

0080 - 00FF

IsLatin-1Supplement

0100 - 017F

IsLatinExtended-A

0180 - 024F

IsLatinExtended-B

0250 - 02AF

IsIPAExtensions

02B0 - 02FF

IsSpacingModifierLetters

0300 - 036F

IsCombiningDiacriticalMarks

0370 - 03FF

IsGreek

- ou -

IsGreekandCoptic

0400 - 04FF

IsCyrillic

0500 - 052F

IsCyrillicSupplement

0530 - 058F

IsArmenian

0590 - 05FF

IsHebrew

0600 - 06FF

IsArabic

0700 - 074F

IsSyriac

0780 - 07BF

IsThaana

097F - 0900

IsDevanagari

0980 - 09FF

IsBengali

0A00 - 0A7F

IsGurmukhi

0A80 - 0AFF

IsGujarati

0B00 - 0B7F

IsOriya

0B80 - 0BFF

IsTamil

0C00 - 0C7F

IsTelugu

0C80 - 0CFF

IsKannada

0D00 - 0D7F

IsMalayalam

0D80 - 0DFF

IsSinhala

0E00 - 0E7F

IsThai

0E80 - 0EFF

IsLao

0F00 - 0FFF

IsTibetan

1000 - 109F

IsMyanmar

10A0 - 10FF

IsGeorgian

1100 - 11FF

IsHangulJamo

1200 - 137F

IsEthiopic

13A0 - 13FF

IsCherokee

1400 - 167F

IsUnifiedCanadianAboriginalSyllabics

1680 - 169F

IsOgham

16A0 - 16FF

IsRunic

1700 - 171F

IsTagalog

1720 - 173F

IsHanunoo

1740 - 175F

IsBuhid

1760 - 177F

IsTagbanwa

1780 - 17FF

IsKhmer

1800 - 18AF

IsMongolian

1900 - 194F

IsLimbu

1950 - 197F

IsTaiLe

19E0 - 19FF

IsKhmerSymbols

1D00 - 1D7F

IsPhoneticExtensions

1E00 - 1EFF

IsLatinExtendedAdditional

1F00 - 1FFF

IsGreekExtended

2000 - 206F

IsGeneralPunctuation

2070 - 209F

IsSuperscriptsandSubscripts

20A0 - 20CF

IsCurrencySymbols

20D0 - 20FF

IsCombiningDiacriticalMarksforSymbols

- ou -

IsCombiningMarksforSymbols

2100 - 214F

IsLetterlikeSymbols

2150 - 218F

IsNumberForms

2190 - 21FF

IsArrows

2200 - 22FF

IsMathematicalOperators

2300 - 23FF

IsMiscellaneousTechnical

2400 - 243F

IsControlPictures

2440 - 245F

IsOpticalCharacterRecognition

2460 - 24FF

IsEnclosedAlphanumerics

2500 - 257F

IsBoxDrawing

2580 - 259F

IsBlockElements

25A0 - 25FF

IsGeometricShapes

2600 - 26FF

IsMiscellaneousSymbols

2700 - 27BF

IsDingbats

27C0 - 27EF

IsMiscellaneousMathematicalSymbols-A

27F0 - 27FF

IsSupplementalArrows-A

2800 - 28FF

IsBraillePatterns

2900 - 297F

IsSupplementalArrows-B

2980 - 29FF

IsMiscellaneousMathematicalSymbols-B

2A00 - 2AFF

IsSupplementalMathematicalOperators

2B00 - 2BFF

IsMiscellaneousSymbolsandArrows

2E80 - 2EFF

IsCJKRadicalsSupplement

2F00 - 2FDF

IsKangxiRadicals

2FF0 - 2FFF

IsIdeographicDescriptionCharacters

3000 - 303F

IsCJKSymbolsandPunctuation

3040 - 309F

IsHiragana

30A0 - 30FF

IsKatakana

3100 - 312F

IsBopomofo

3130 - 318F

IsHangulCompatibilityJamo

3190 - 319F

IsKanbun

31A0 - 31BF

IsBopomofoExtended

31F0 - 31FF

IsKatakanaPhoneticExtensions

3200 - 32FF

IsEnclosedCJKLettersandMonths

3300 - 33FF

IsCJKCompatibility

3400 - 4DBF

IsCJKUnifiedIdeographsExtensionA

4DC0 - 4DFF

IsYijingHexagramSymbols

4E00 - 9FFF

IsCJKUnifiedIdeographs

A000 - A48F

IsYiSyllables

A490 - A4CF

IsYiRadicals

AC00 - D7AF

IsHangulSyllables

D800 - DB7F

IsHighSurrogates

DB80 - DBFF

IsHighPrivateUseSurrogates

DC00 - DFFF

IsLowSurrogates

E000 - F8FF

IsPrivateUseouIsPrivateUseArea

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

Voltar ao início

Subtração de classe de caractere

Uma classe de caractere define um conjunto de caracteres. A subtração de classe de caractere fornece um conjunto de caracteres que é o resultado da exclusão dos caracteres em uma classe de caractere a partir de outra classe de caractere.

A subtração de classe de caractere tem a seguinte forma:

[base_group-[excluded_group]]

Os colchetes ([]) e hífen (-) são obrigatórios. O grupo_base é um grupo de caracteres positivo ou negativo conforme descrito na tabela Sintaxe de Classes de Caracteres. O componente grupo_excluído é outro grupo de caracteres positivo ou negativo, ou outra expressão de subtração de classe de caracteres (ou seja, você pode aninhar expressões de subtração classe de caractere).

Por exemplo, suponha que você tiver um grupo base que consiste o intervalo de caracteres de "a" a "z". Para definir o conjunto de caracteres que consiste o grupo base, exceto para o caractere "m", use [a-z-[m]]. Para definir o conjunto de caracteres que consiste o grupo base, exceto para o conjunto de caracteres "d", "j" e "p", use [a-z-[djp]]. Para definir o conjunto de caracteres que consiste o grupo de base, exceto para o intervalo de caracteres de "m" por meio de "p", use [a-z-[m-p]].

Considere a expressão de subtração de classe de caractere aninhada, [a-z-[d-w-[m-o]]]. A expressão é calculada do intervalo de caractere mais interno para fora. Primeiro, o intervalo de caracteres de "m" por meio de "o" é subtraído do intervalo de caracteres "d" por meio de "w", que gera o conjunto de caracteres de "d" por meio de "l" e "p" por meio de "w". Que conjunto é subtraído do intervalo de caracteres, de "a" a "z", que gera o conjunto de caracteres [abcmnoxyz].

Você pode usar qualquer classe de caractere com subtração de classes de caractere. Para definir o conjunto de caracteres que consiste em todos os caracteres Unicode de \u0000 por meio de \uFFFF, exceto os caracteres de espaço em branco (\s), os caracteres na categoria geral de pontuação (\p{P}), os caracteres a IsGreek chamado bloco (\p{IsGreek}), e o caractere de controle Unicode próxima linha (\x85), use [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].

Escolha classes de caracteres para uma expressão de subtração de classes de caractere que produzirá resultados utéis. Evite uma expressão que gere um conjunto de caracteres vazio, que não podem corresponder a nada, ou uma expressão que é equivalente ao grupo base original. Por exemplo, o conjunto vazio é o resultado da expressão [\p{IsBasicLatin}-[\x00-\x7F]], que todos os caracteres no qual subtrai o IsBasicLatin caracteres variam 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, o que é o intervalo de caracteres de letras de "a" a "z", não pode conter caracteres no grupo excluído, o que é o intervalo de caracteres de dígitos decimais de "0" por meio de "9".

O exemplo a seguir define uma expressão regular, ^[0-9-[2468]]+$, que corresponde a zero e dígitos estranhas em uma seqüência de caracteres de entrada. A expressão regular é interpretada como mostrado na tabela a seguir.

Elemento

Descrição

^

Começa a correspondência no início da seqüência de entrada.

[0-9-[2468]]+

Corresponde a uma ou mais ocorrências de qualquer caractere de 0 a 9, exceto para 2, 4, 6 e 8. Em outras palavras, corresponde a uma ou mais ocorrências de zero ou um dígito ímpar.

$

Finalize a correspondência no final da seqüência de entrada.

 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "123", "13579753", "3557798", "335599901" }
      Dim pattern As String = "^[0-9-[2468]]+$"

      For Each input As String In inputs
         Dim match As Match = Regex.Match(input, pattern)
         If match.Success Then Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       13579753
'       335599901

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "123", "13579753", "3557798", "335599901" };
      string pattern = @"^[0-9-[2468]]+$";

      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern);
         if (match.Success) 
            Console.WriteLine(match.Value);
      }      
   }
}
// The example displays the following output:
//       13579753
//       335599901

Voltar ao início

Consulte também

Referência

GetUnicodeCategory

Opções de expressões regulares

Conceitos

Elementos de linguagem das expressões regulares