Classes de caracteres em expressões regulares

Uma classe de caractere define um conjunto de caracteres, qualquer um dos quais pode ocorrer em uma cadeia de caracteres de entrada para que uma correspondência seja bem-sucedida. A linguagem de expressão regular no .NET suporta as seguintes classes de caracteres:

• Grupos de caráter positivo. Um caractere na cadeia de caracteres de entrada deve corresponder a um de um conjunto especificado de caracteres. Para obter mais informações, consulte Grupo de caracteres positivos.

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

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

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

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

• Um caractere de palavra. Um caractere na cadeia de caracteres de entrada pode pertencer a qualquer uma das categorias Unicode apropriadas para caracteres em palavras. Para obter mais informações, consulte Caractere do Word.

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

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

• Um caractere sem espaço em branco. Um caractere na cadeia de caracteres de entrada pode ser qualquer caractere que não seja um caractere de espaço em branco. Para obter mais informações, consulte Caractere sem espaço em branco.

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

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

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

Grupo de caracteres positivos: [ ]

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

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

[*character_group*]

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

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

[firstCharacter-lastCharacter]

onde firstCharacter é o caractere que inicia o intervalo e lastCharacter é o caractere que termina o intervalo. Um intervalo de caracteres é uma série contígua de caracteres definida especificando o primeiro caractere da série, um hífen (-) e, em seguida, o último caractere da série. Dois caracteres são contíguos se tiverem pontos de código Unicode adjacentes. firstCharacter deve ser o caractere com o ponto de código inferior e lastCharacter deve ser o caractere com o ponto de código mais alto.

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

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

O exemplo a seguir define um grupo de caracteres positivos que contém os caracteres "a" e "e" para que a cadeia de caracteres de entrada contenha as palavras "cinza" ou "cinza" seguidas por outra palavra para que ocorra uma correspondência.

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

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

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

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

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

Grupo de caracteres negativos: [^]

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

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

[*^character_group*]

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

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

[^*firstCharacter*-*lastCharacter*]

onde firstCharacter é o caractere que inicia o intervalo e lastCharacter é o caractere que termina o intervalo. Um intervalo de caracteres é uma série contígua de caracteres definida especificando o primeiro caractere da série, um hífen (-) e, em seguida, o último caractere da série. Dois caracteres são contíguos se tiverem pontos de código Unicode adjacentes. firstCharacter deve ser o caractere com o ponto de código inferior e lastCharacter deve ser o caractere com o ponto de código mais alto.

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

O caractere de acento circunflexo principal (^) em um grupo de caracteres negativos é obrigatório e indica que o grupo de caracteres é um grupo de caracteres negativos em vez de um grupo de caracteres positivos.

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

O exemplo a seguir corresponde a qualquer palavra que começa com os caracteres "th" e não é seguida por um "o".

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

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

Qualquer personagem: .

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

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

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

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

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

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

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

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

Categoria Unicode ou bloco Unicode: \p{}

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

A construção da expressão regular

\p{Designação }

corresponde a qualquer caractere que pertença a uma categoria geral Unicode ou bloco nomeado, onde nome é a abreviatura da categoria ou nome do bloco nomeado. Para obter uma lista de abreviaturas de categoria, consulte a seção Categorias gerais Unicode suportadas mais adiante neste tópico. Para obter uma lista de blocos nomeados, consulte a seção Blocos nomeados suportados mais adiante neste tópico.

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

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

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

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

Categoria Unicode negativa ou bloco Unicode: \P{}

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

A construção da expressão regular

\P{Designação }

corresponde a qualquer caractere que não pertença a uma categoria geral Unicode ou bloco nomeado, onde nome é a abreviatura da categoria ou nome do bloco nomeado. Para obter uma lista de abreviaturas de categoria, consulte a seção Categorias gerais Unicode suportadas mais adiante neste tópico. Para obter uma lista de blocos nomeados, consulte a seção Blocos nomeados suportados mais adiante neste tópico.

O exemplo a seguir usa a \P{construção name} para remover quaisquer símbolos de moeda (neste caso, a Sccategoria , ou Symbol, Currency) de cadeias de caracteres numéricas.

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

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

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

Caractere da palavra: \w

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

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

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

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

Caractere não-palavra: \W

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

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

Em outras palavras, ele corresponde a qualquer caractere, exceto aqueles nas categorias Unicode listadas na tabela a seguir.

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

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

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

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

Caractere de espaço em branco: \s

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

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

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

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

Caractere sem espaço em branco: \S

\S corresponde a qualquer caractere que não seja de espaço em branco. É equivalente ao [^\f\n\r\t\v\x85\p{Z}] padrão de expressão regular, ou o oposto do padrão de expressão regular que é equivalente a , que corresponde a \scaracteres de espaço em branco. Para obter mais informações, consulte Caractere de espaço em branco: \s.

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

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

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

Caractere de dígito decimal: \d

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

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

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

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

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

Caractere sem dígitos: \D

\D corresponde a qualquer caractere sem dígitos. É equivalente ao padrão de \P{Nd} expressão regular.

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

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

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

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

Categorias gerais Unicode suportadas

Unicode define as categorias gerais listadas na tabela a seguir. Para obter mais informações, consulte os subtópicos "Formato de arquivo UCD" e "Valores gerais de categoria" no banco de dados de caracteres Unicode, Seção 5.7.1, Tabela 12.

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

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

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

Blocos nomeados suportados

O .NET fornece os blocos nomeados listados na tabela a seguir. O conjunto de blocos nomeados suportados é baseado em Unicode 4.0 e Perl 5.6. Para obter uma expressão regular que usa blocos nomeados, consulte a categoria Unicode ou bloco Unicode: seção \p{} .

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

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

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

[ -[ base_group excluded_group ]]

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

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

Considere a expressão de subtração da classe de caractere aninhada, [a-z-[d-w-[m-o]]]. A expressão é avaliada a partir da faixa de caracteres mais interna para fora. Primeiro, o intervalo de caracteres de "m" a "o" é subtraído do intervalo de caracteres "d" a "w", o que produz o conjunto de caracteres de "d" a "l" e "p" a "w". Esse conjunto é então subtraído do intervalo de caracteres de "a" a "z", o que produz o conjunto de caracteres [abcmnoxyz].

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

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

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

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

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

Consulte também

• GetUnicodeCategory
• Linguagem de Expressão Regular - Referência Rápida
• Opções de expressão regular