Classes de caracteres em expressões regulares

Uma classe de caracteres define um conjunto de caracteres, qualquer dos quais pode ocorrer em uma cadeia de caracteres de entrada para que uma correspondência seja bem-sucedida. A linguagem de expressões regulares no .NET dá suporte às seguintes classes de caracteres:

• Grupos de caracteres positivos. Um caractere na cadeia de caracteres de entrada deve corresponder a um de um conjunto especificado de caracteres. Para obter mais informações, consulte Positive Character Group (Grupo de caracteres positivos).

• Grupo de caracteres negativos. Um caractere na cadeia de caracteres de entrada não deve corresponder a um de um conjunto especificado de caracteres. Para obter mais informações, consulte Negative Character Group (Grupo de caracteres negativos).

• Qualquer caractere. O . (ponto) em uma expressão regular é um caractere curinga que corresponde a qualquer caractere, exceto \n. Para obter mais informações, consulte Qualquer caractere.

• Uma categoria geral de Unicode ou bloco nomeado. Um caractere na cadeia de caracteres de entrada deve ser um membro de uma categoria de Unicode específica ou deve estar dentro de um intervalo contíguo de caracteres Unicode para que uma correspondência seja bem-sucedida. Para obter mais informações, consulte Unicode Category or Unicode Block (Bloco de Unicode ou Categoria de Unicode).

• Uma categoria geral de Unicode ou bloco nomeado negativos. Um caractere na cadeia de caracteres de entrada não deve ser um membro de uma categoria de Unicode específica ou não deve estar dentro de um intervalo contíguo de caracteres Unicode para que uma correspondência seja bem-sucedida. Para obter mais informações, consulte Negative Unicode Category or Unicode Block (Categoria Unicode Negativa ou bloco Unicode).

• Um caractere de palavra. Um caractere na cadeia de caracteres de entrada pode pertencer a qualquer uma das categorias Unicode que são apropriados para caracteres usados em palavras. Para obter mais informações, consulte Word Character (Caractere de palavra).

• Um caractere não pertencente a palavras. Um caractere na cadeia de caracteres de entrada pode pertencer a qualquer categoria Unicode que não seja um caractere de palavra. Para obter mais informações, consulte Non-Word Character (Caractere não pertencente a palavras).

• Um caractere de espaço em branco. Um caractere na cadeia de caracteres de entrada pode ser qualquer caractere separador Unicode, bem como qualquer um entre vários caracteres de controle. Para obter mais informações, consulte White-Space Character (Caractere de espaço em branco).

• Um caractere diferente de espaço em branco. Um caractere na cadeia de caracteres de entrada pode ser qualquer caractere que não seja um caractere de espaço em branco. Para obter mais informações, consulte Non-White-Space Character (Caractere diferente de espaço em branco).

• Um dígito decimal. Um caractere na cadeia de caracteres de entrada pode ser qualquer um entre vários caracteres classificados como dígitos decimais Unicode. Para obter mais informações, consulte Decimal Digit Character (Caractere de dígito decimal).

• Um dígito não decimal. Um caractere na cadeia de caracteres de entrada pode ser qualquer coisa que não seja um dígito decimal Unicode. Para obter mais informações, consulte Decimal Digit Character (Caractere de dígito decimal).

O .NET dá suporte a expressões de subtração de classes de caracteres, o que permite a você definir um conjunto de caracteres como resultado da exclusão de uma classe de caracteres de outra classe de caracteres. Para obter mais informações, consulte Subtração de classe de caracteres.

Grupo de caracteres positivo: [ ]

Um grupo de caracteres positivos especifica uma lista de caracteres, qualquer caractere dela pode aparecer em uma cadeia de caracteres de entrada para que uma correspondência ocorra. Essa lista de caracteres pode ser especificada individualmente, como um intervalo ou ambos.

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

[*character_group*]

em que character_group é uma lista dos caracteres individuais que podem aparecer na cadeia de caracteres de entrada para que uma correspondência seja bem-sucedida. character_group pode ser composto por qualquer combinação de um ou mais caracteres literais, caracteres de escape ou classes de caracteres.

A sintaxe para especificar um intervalo de caracteres é a seguinte:

[firstCharacter-lastCharacter]

em que firstCharacter é o caractere que inicia o intervalo e lastCharacter é o caractere que encerra o intervalo. Um intervalo de caracteres é uma série contígua de caracteres definida pela especificação do primeiro caractere na série, um hífen (-) e o último caractere na série. Dois caracteres são contíguos se eles têm pontos de código Unicode adjacentes. firstCharacter precisa ser o caractere com o ponto de código menor, enquanto lastCharacter precisa ser o caractere com o ponto de código maior.

Para incluir um hífen como um membro não periférico de um grupo de caracteres, escape-o. Por exemplo, para criar um grupo de caracteres para o caractere a e os caracteres de - a /, a sintaxe correta é [a\--/].

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

O exemplo a seguir define um grupo de caracteres positivos que contém os caracteres “a” e “e” para que a cadeia de caracteres de entrada contenha as palavras “grey” ou “gray” seguida de outra palavra para que uma correspondência ocorra.

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

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

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

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

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

Grupo de caracteres negativos: [^]

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

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

[*^character_group*]

em que character_group é uma lista dos caracteres individuais que não podem aparecer na cadeia de caracteres de entrada para que uma correspondência seja bem-sucedida. character_group pode ser composto por qualquer combinação de um ou mais caracteres literais, caracteres de escape ou classes de caracteres.

A sintaxe para especificar um intervalo de caracteres é a seguinte:

[^*firstCharacter*-*lastCharacter*]

em que firstCharacter é o caractere que inicia o intervalo e lastCharacter é o caractere que encerra o intervalo. Um intervalo de caracteres é uma série contígua de caracteres definida pela especificação do primeiro caractere na série, um hífen (-) e o último caractere na série. Dois caracteres são contíguos se eles têm pontos de código Unicode adjacentes. firstCharacter precisa ser o caractere com o ponto de código menor, enquanto lastCharacter precisa ser o caractere com o ponto de código maior.

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

O caractere de circunflexo à esquerda (^) em um grupo de caracteres negativos é obrigatório e indica que o grupo de caracteres é um grupo de caracteres negativos, e não um grupo de caracteres positivos.

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

O exemplo a seguir corresponde a todas as palavras que começam com os caracteres “th” e não são seguidas por um “o”.

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

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

Qualquer caractere: .

O caractere de ponto (.) corresponde a qualquer caractere, exceto \n (o caractere de nova linha), com estas duas qualificações:

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

  O exemplo a seguir ilustra o comportamento diferente da classe de caracteres . por padrão e com a opção RegexOptions.Singleline. A expressão regular ^.+ começa no início da cadeia de caracteres e corresponde a todos os caracteres. Por padrão, a correspondência termina no final da primeira linha; o padrão de expressão regular corresponde ao caractere de retorno de carro, \r, mas não corresponde a \n. Como a opção RegexOptions.Singleline interpreta toda a cadeia de caracteres de entrada como uma única linha, ela corresponde a cada caractere na cadeia de caracteres de entrada, incluindo \n.

  using System;
  using System.Text.RegularExpressions;
  
  public class Example
  {
     public static void Main()
     {
        string pattern = "^.+";
        string input = "This is one line and" + Environment.NewLine + "this is the second.";
        foreach (Match match in Regex.Matches(input, pattern))
           Console.WriteLine(Regex.Escape(match.Value));
  
        Console.WriteLine();
        foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline))
           Console.WriteLine(Regex.Escape(match.Value));
     }
  }
  // The example displays the following output:
  //       This\ is\ one\ line\ and\r
  //
  //       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
  

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

• Em um grupo de caracteres positivos ou negativos, um ponto é tratado como um caractere de ponto literal e não como uma classe de caracteres. Para saber mais, confira Grupo de caracteres positivos e Grupo de caracteres negativos anteriormente neste tópico. O exemplo a seguir fornece uma ilustração ao definir uma expressão regular que inclui o caractere de ponto (.) como uma classe de caracteres e como um membro de um grupo de caracteres positivos. A expressão regular \b.*[.?!;:](\s|\z) começa em um limite de palavra, corresponde a qualquer caractere até encontrar um de cinco sinais de pontuação, incluindo um ponto, e corresponde a um caractere de espaço em branco ou ao final da cadeia de caracteres.

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

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

Categoria de Unicode ou bloco Unicode: \p{}

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

A constructo da expressão regular

\p{ nome }

corresponde a qualquer caractere que pertence a uma categoria geral de Unicode ou a um bloco nomeado, em que name é a abreviação da categoria ou o nome do bloco nomeado. Para obter uma lista de abreviações de categoria, consulte a seção Categorias gerais Unicode com suporte posteriormente neste tópico. Para obter uma lista dos blocos nomeados, consulte a seção Blocos nomeados com suporte posteriormente neste tópico.

O exemplo a seguir usa o constructo \p{name} para corresponder a uma categoria de Unicode geral (nesse caso, a categoria Pd ou Pontuação, Traço) e a um bloco nomeado (os blocos nomeados IsGreek e IsBasicLatin).

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

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

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

Categoria Unicode negativa ou bloco Unicode: \P{}

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

A constructo da expressão regular

\P{ nome }

corresponde a qualquer caractere que não pertença a uma categoria geral de Unicode ou a um bloco nomeado, em que name é a abreviação da categoria ou o nome do bloco nomeado. Para obter uma lista de abreviações de categoria, consulte a seção Categorias gerais Unicode com suporte posteriormente neste tópico. Para obter uma lista dos blocos nomeados, consulte a seção Blocos nomeados com suporte posteriormente neste tópico.

O exemplo a seguir usa o constructo \P{name} para remover quaisquer símbolos de moeda (nesse caso, categoria Sc, ou Símbolo, Moeda) de cadeias de caracteres numéricas.

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

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

O padrão de expressão regular (\P{Sc})+ corresponde a um ou mais caracteres que não são símbolos de moeda; ele remove efetivamente qualquer símbolo de moeda da cadeia de caracteres de resultado.

Caractere de palavra: \w

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

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

O exemplo a seguir usa o elemento de linguagem \w para corresponder a caracteres duplicados em uma palavra. O exemplo define um padrão de expressão regular, (\w)\1, que pode ser interpretado como a seguir.

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

Caractere não pertencente a palavras: \W

\W corresponde a qualquer caractere que não seja uma palavra. O elemento de linguagem \W é equivalente à seguinte classe de caracteres:

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

Em outras palavras, ele corresponde a qualquer caractere, com exceção dos listados nas categorias de Unicode na tabela a seguir.

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

O exemplo a seguir ilustra a classe de caracteres \W. Ele define um padrão de expressão regular, \b(\w+)(\W){1,2}, que corresponde a uma palavra seguida por um ou dois caracteres não pertencentes a palavras, como espaço em branco ou pontuação. A expressão regular é interpretada conforme mostrado na tabela a seguir.

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

Como o objeto Group do segundo grupo de captura contém apenas um único caractere capturado não pertencente a palavras, o exemplo recupera todos os caracteres capturados não pertencentes a palavras do objeto CaptureCollection retornado pela propriedade Group.Captures.

Caractere de espaço em branco: \s

\s corresponde a um caractere de espaço em branco. É equivalente às sequências de escape e às categorias de Unicode listadas na tabela a seguir.

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

O exemplo a seguir ilustra a classe de caracteres \s. Ele define um padrão de expressão regular, \b\w+(e)?s(\s|$), que corresponde a uma palavra que termina em “s” ou em “es” seguida por um caractere de espaço em branco ou pelo final da cadeia de caracteres de entrada. A expressão regular é interpretada conforme mostrado na tabela a seguir.

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

Caractere diferente de espaço em branco: \S

\S corresponde a qualquer caractere que não seja um caractere de espaço em branco. Ele é equivalente ao padrão de expressão regular [^\f\n\r\t\v\x85\p{Z}] ou o oposto do padrão de expressão regular equivalente a \s, o qual corresponde a caracteres de espaço em branco. Para saber mais, confira Caractere de espaço em branco: \s.

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

O exemplo a seguir ilustra o elemento de linguagem \S. O padrão de expressão regular \b(\S+)\s? corresponde a cadeias de caracteres que são delimitadas por caracteres de espaço em branco. O segundo elemento no objeto GroupCollection da correspondência contém a cadeia de caracteres correspondida. A expressão regular pode ser interpretada conforme mostrado na tabela a seguir.

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

Caractere de dígito decimal: \d

\d corresponde a qualquer dígito decimal. É equivalente ao padrão de expressão regular \p{Nd}, o qual inclui os dígitos decimais padrão 0-9, bem como os dígitos decimais de vários outros conjuntos de caracteres.

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

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

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

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

Caractere que não seja dígito: \D

\D corresponde a qualquer caractere que não seja um dígito. É equivalente ao padrão de expressão regular \P{Nd}.

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

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

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

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

Categorias gerais Unicode com suporte

O Unicode define as categorias gerais listadas na tabela a seguir. Para obter mais informações, consulte os subtópicos "Formato de arquivo UCD" e "Valores de categoria geral" no Banco de dados de caractere Unicode, Sec. 5.7.1, Tabela 12.

Você pode determinar a categoria Unicode de qualquer caractere específico ao passar esse caractere para o método GetUnicodeCategory. O exemplo a seguir usa o método GetUnicodeCategory para determinar a categoria de cada elemento em uma matriz que contém caracteres latinos selecionados.

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

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

Blocos nomeados compatíveis

O .NET fornece os blocos nomeados listados na tabela a seguir. O conjunto de blocos nomeados com suporte baseia-se no Unicode 4.0 e no Perl 5.6. Para uma expressão regular que usa blocos nomeados, consulte a seção Categoria Unicode ou bloco Unicode: \p{}.

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

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

A expressão de subtração de classes de caracteres tem a seguinte forma:

[ base_group -[ excluded_group ]]

Os colchetes ([]) e hífen (-) são obrigatórios. O base_group é um grupo de caracteres positivos ou um grupo de caracteres negativos. O componente excluded_group é outro grupo de caracteres positivos ou negativos ou outra expressão de subtração de classes de caracteres (ou seja, você pode aninhar expressões de subtração de classes de caracteres).

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

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

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

Escolha classes de caracteres para uma expressão de subtração de classes de caracteres que produza resultados úteis. Evite uma expressão que gere um conjunto de caracteres vazio, que não podem corresponder a nada ou uma expressão equivalente ao grupo base original. Por exemplo, o conjunto vazio é o resultado da expressão [\p{IsBasicLatin}-[\x00-\x7F]], que subtrai todos os caracteres do intervalo de caracteres IsBasicLatin da categoria geral IsBasicLatin. Da mesma forma, o grupo base original é o resultado da expressão [a-z-[0-9]]. Isso ocorre, porque o grupo base, que é o intervalo de caracteres de letras de "a" a "z", não contém quaisquer caracteres no grupo excluído, que é o intervalo de caracteres de dígitos decimais de "0" a "9".

O exemplo a seguir define uma expressão regular, ^[0-9-[2468]]+$, que corresponde aos dígitos zero e ímpares em uma cadeia de caracteres de entrada. A expressão regular é interpretada conforme mostrado na tabela a seguir.

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

Confira também

• GetUnicodeCategory
• Linguagem de expressões regulares – referência rápida
• Opções de expressões regulares