Expressões regulares do .NET.NET Regular Expressions

Expressões regulares oferecem um método poderoso, flexível e eficiente de processamento de texto.Regular expressions provide a powerful, flexible, and efficient method for processing text. A extensiva notação de correspondência de padrões de expressões regulares permite que você analise rapidamente grandes quantidades de texto para encontrar padrões de caracteres específicos; para validar o texto e garantir que ele corresponda a um padrão predefinido (como um endereço de email); para extrair, editar, substituir ou excluir subcadeias de caracteres de texto; e para adicionar as cadeias de caracteres extraídas para uma coleção a fim de gerar um relatório.The extensive pattern-matching notation of regular expressions enables you to quickly parse large amounts of text to find specific character patterns; to validate text to ensure that it matches a predefined pattern (such as an email address); to extract, edit, replace, or delete text substrings; and to add the extracted strings to a collection in order to generate a report. Para vários aplicativos que lidam com cadeias de caracteres ou que analisam grandes blocos de texto, as expressões regulares são uma ferramenta indispensável.For many applications that deal with strings or that parse large blocks of text, regular expressions are an indispensable tool.

Como funcionam as expressões regularesHow Regular Expressions Work

A parte mais importante do processamento de texto com expressões regulares é o mecanismo de expressão regular, que é representado pelo objeto System.Text.RegularExpressions.Regex no .NET.The centerpiece of text processing with regular expressions is the regular expression engine, which is represented by the System.Text.RegularExpressions.Regex object in .NET. No mínimo, o processamento de texto usando expressões regulares exige que o mecanismo de expressões regulares seja fornecido com os dois itens informativos a seguir:At a minimum, processing text using regular expressions requires that the regular expression engine be provided with the following two items of information:

  • O padrão de expressão regular a ser identificado no texto.The regular expression pattern to identify in the text.

    No .NET, padrões de expressão regular são definidos por uma sintaxe ou linguagem especial, compatível com expressões regulares Perl 5 e inclui alguns recursos adicionais, como correspondência da direita para a esquerda.In .NET, regular expression patterns are defined by a special syntax or language, which is compatible with Perl 5 regular expressions and adds some additional features such as right-to-left matching. Para obter mais informações, consulte Linguagem de expressões regulares – referência rápida.For more information, see Regular Expression Language - Quick Reference.

  • O texto a ser analisado para o padrão de expressão regular.The text to parse for the regular expression pattern.

Os métodos da classe Regex permitem que você realize as seguintes operações:The methods of the Regex class let you perform the following operations:

Para obter uma visão geral do modelo de objeto de expressão regular, consulte O modelo de objeto de expressão regular.For an overview of the regular expression object model, see The Regular Expression Object Model.

Para saber mais sobre a linguagem de expressão regular, confira Linguagem de expressão regular - referência rápida ou faça download e imprima um dos seguintes folhetos:For more information about the regular expression language, see Regular Expression Language - Quick Reference or download and print one of these brochures:

Referência rápida no formato Word (.docx)Quick Reference in Word (.docx) format
Referência rápida no formato PDF (.pdf)Quick Reference in PDF (.pdf) format

Exemplos de expressões regularesRegular Expression Examples

A classe String inclui uma série de métodos de pesquisa de cadeia de caracteres e substituição que podem ser usados quando você quer localizar cadeias de caracteres literais em uma cadeia de caracteres maior.The String class includes a number of string search and replacement methods that you can use when you want to locate literal strings in a larger string. Expressões regulares são mais úteis quando você quer localizar uma dentre diversas subcadeias de caracteres em uma cadeia de caracteres maior ou quando quer identificar padrões em uma cadeia de caracteres, como mostrado nos exemplos a seguir.Regular expressions are most useful either when you want to locate one of several substrings in a larger string, or when you want to identify patterns in a string, as the following examples illustrate.

Exemplo 1: Substituindo subcadeias de caracteresExample 1: Replacing Substrings

Vamos presumir que uma lista de endereçamento contém nomes que, às vezes, incluem um pronome de tratamento (Sr., Srs., Srta. ou Sra.) junto com o nome e o sobrenome.Assume that a mailing list contains names that sometimes include a title (Mr., Mrs., Miss, or Ms.) along with a first and last name. Se não quiser incluir os pronomes de tratamento ao gerar etiquetas para envelopes na lista, é possível usar uma expressão regular para removê-los, como mostrado no exemplo a seguir.If you do not want to include the titles when you generate envelope labels from the list, you can use a regular expression to remove the titles, as the following example illustrates.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(Mr\\.? |Mrs\\.? |Miss |Ms\\.? )";
      string[] names = { "Mr. Henry Hunt", "Ms. Sara Samuels", 
                         "Abraham Adams", "Ms. Nicole Norris" };
      foreach (string name in names)
         Console.WriteLine(Regex.Replace(name, pattern, String.Empty));
   }
}
// The example displays the following output:
//    Henry Hunt
//    Sara Samuels
//    Abraham Adams
//    Nicole Norris
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(Mr\.? |Mrs\.? |Miss |Ms\.? )"
      Dim names() As String = { "Mr. Henry Hunt", "Ms. Sara Samuels", _
                                "Abraham Adams", "Ms. Nicole Norris" }
      For Each name As String In names
         Console.WriteLine(Regex.Replace(name, pattern, String.Empty))
      Next                                
   End Sub
End Module
' The example displays the following output:
'    Henry Hunt
'    Sara Samuels
'    Abraham Adams
'    Nicole Norris

O padrão de expressão regular (Mr\.? |Mrs\.? |Miss |Ms\.? ) corresponde a qualquer ocorrência de “Sr”, “Sr.”, “Sra”, “Sra.”, “Srta” ou “Srta.”.The regular expression pattern (Mr\.? |Mrs\.? |Miss |Ms\.? ) matches any occurrence of "Mr ", "Mr. ", "Mrs ", "Mrs. ", "Miss ", "Ms or "Ms. ". A chamada para o método Regex.Replace substitui a cadeia de caracteres correspondida por String.Empty; em outras palavras, ela a remove da cadeia de caracteres original.The call to the Regex.Replace method replaces the matched string with String.Empty; in other words, it removes it from the original string.

Exemplo 2: Identificando palavras duplicadasExample 2: Identifying Duplicated Words

Duplicar palavras acidentalmente é um erro comum que escritores cometem.Accidentally duplicating words is a common error that writers make. Uma expressão regular pode ser usada para identificar palavras duplicadas, como mostrado no exemplo a seguir.A regular expression can be used to identify duplicated words, as the following example shows.

using System;
using System.Text.RegularExpressions;

public class Class1
{
   public static void Main()
   {
      string pattern = @"\b(\w+?)\s\1\b";
      string input = "This this is a nice day. What about this? This tastes good. I saw a a dog.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("{0} (duplicates '{1}') at position {2}", 
                           match.Value, match.Groups[1].Value, match.Index);
   }
}
// The example displays the following output:
//       This this (duplicates 'This') at position 0
//       a a (duplicates 'a') at position 66
Imports System.Text.RegularExpressions

Module modMain
   Public Sub Main()
      Dim pattern As String = "\b(\w+?)\s\1\b"
      Dim input As String = "This this is a nice day. What about this? This tastes good. I saw a a dog."
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("{0} (duplicates '{1}') at position {2}", _
                           match.Value, match.Groups(1).Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       This this (duplicates 'This') at position 0
'       a a (duplicates 'a') at position 66

O padrão de expressão regular \b(\w+?)\s\1\b pode ser interpretado da seguinte maneira:The regular expression pattern \b(\w+?)\s\1\b can be interpreted as follows:

\b Iniciar em um limite de palavra.Start at a word boundary.
(\w+?)(\w+?) Corresponder a um ou mais caracteres de palavra, mas o menor número de caracteres possível.Match one or more word characters, but as few characters as possible. Juntos, formam um grupo que pode ser chamado de \1.Together, they form a group that can be referred to as \1.
\s Corresponde a um caractere de espaço em branco.Match a white-space character.
\1 Corresponder à subcadeia de caracteres que é igual ao grupo denominado \1.Match the substring that is equal to the group named \1.
\b Corresponder a um limite de palavra.Match a word boundary.

O método Regex.Matches é chamado com opções de expressão regular definidas como RegexOptions.IgnoreCase.The Regex.Matches method is called with regular expression options set to RegexOptions.IgnoreCase. Portanto, a operação de correspondência não faz distinção entre maiúsculas e minúsculas e o exemplo identifica a subcadeia de caracteres “This this” como uma duplicação.Therefore, the match operation is case-insensitive, and the example identifies the substring "This this" as a duplication.

Observe que a cadeia de caracteres de entrada inclui a subcadeia de caracteres “this?Note that the input string includes the substring "this? This”.This". No entanto, devido à pontuação no meio, ela não é identificada como uma duplicação.However, because of the intervening punctuation mark, it is not identified as a duplication.

Exemplo 3: Compilando dinamicamente uma expressão regular com detecção de culturaExample 3: Dynamically Building a Culture-Sensitive Regular Expression

O exemplo a seguir mostra a força das expressões regulares combinada à flexibilidade oferecida pelos recursos de globalização do .NET.The following example illustrates the power of regular expressions combined with the flexibility offered by .NET's globalization features. Ele utiliza o objeto NumberFormatInfo para determinar o formato de valores de moeda na cultura atual do sistema.It uses the NumberFormatInfo object to determine the format of currency values in the system's current culture. Então, essa informação é usada para construir dinamicamente uma expressão regular que extrai valores de moeda do texto.It then uses that information to dynamically construct a regular expression that extracts currency values from the text. Para cada correspondência, ele extrai o subgrupo que contém somente a subcadeia de caracteres, converte-a para um valor Decimal e calcula uma soma acumulada.For each match, it extracts the subgroup that contains the numeric string only, converts it to a Decimal value, and calculates a running total.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Define text to be parsed.
      string input = "Office expenses on 2/13/2008:\n" + 
                     "Paper (500 sheets)                      $3.95\n" + 
                     "Pencils (box of 10)                     $1.00\n" + 
                     "Pens (box of 10)                        $4.49\n" + 
                     "Erasers                                 $2.19\n" + 
                     "Ink jet printer                        $69.95\n\n" + 
                     "Total Expenses                        $ 81.58\n"; 
      
      // Get current culture's NumberFormatInfo object.
      NumberFormatInfo nfi = CultureInfo.CurrentCulture.NumberFormat;
      // Assign needed property values to variables.
      string currencySymbol = nfi.CurrencySymbol;
      bool symbolPrecedesIfPositive = nfi.CurrencyPositivePattern % 2 == 0;
      string groupSeparator = nfi.CurrencyGroupSeparator;
      string decimalSeparator = nfi.CurrencyDecimalSeparator;

      // Form regular expression pattern.
      string pattern = Regex.Escape( symbolPrecedesIfPositive ? currencySymbol : "") + 
                       @"\s*[-+]?" + "([0-9]{0,3}(" + groupSeparator + "[0-9]{3})*(" + 
                       Regex.Escape(decimalSeparator) + "[0-9]+)?)" + 
                       (! symbolPrecedesIfPositive ? currencySymbol : ""); 
      Console.WriteLine( "The regular expression pattern is:");
      Console.WriteLine("   " + pattern);      

      // Get text that matches regular expression pattern.
      MatchCollection matches = Regex.Matches(input, pattern, 
                                              RegexOptions.IgnorePatternWhitespace);               
      Console.WriteLine("Found {0} matches.", matches.Count); 

      // Get numeric string, convert it to a value, and add it to List object.
      List<decimal> expenses = new List<Decimal>();
                     
      foreach (Match match in matches)
         expenses.Add(Decimal.Parse(match.Groups[1].Value));      

      // Determine whether total is present and if present, whether it is correct.
      decimal total = 0;
      foreach (decimal value in expenses)
         total += value;
      
      if (total / 2 == expenses[expenses.Count - 1]) 
         Console.WriteLine("The expenses total {0:C2}.", expenses[expenses.Count - 1]);
      else
         Console.WriteLine("The expenses total {0:C2}.", total);
   }  
}
// The example displays the following output:
//       The regular expression pattern is:
//          \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?)
//       Found 6 matches.
//       The expenses total $81.58.
Imports System.Collections.Generic
Imports System.Globalization
Imports System.Text.RegularExpressions

Public Module Example
   Public Sub Main()
      ' Define text to be parsed.
      Dim input As String = "Office expenses on 2/13/2008:" + vbCrLf + _
                            "Paper (500 sheets)                      $3.95" + vbCrLf + _
                            "Pencils (box of 10)                     $1.00" + vbCrLf + _
                            "Pens (box of 10)                        $4.49" + vbCrLf + _
                            "Erasers                                 $2.19" + vbCrLf + _
                            "Ink jet printer                        $69.95" + vbCrLf + vbCrLf + _
                            "Total Expenses                        $ 81.58" + vbCrLf
      ' Get current culture's NumberFormatInfo object.
      Dim nfi As NumberFormatInfo = CultureInfo.CurrentCulture.NumberFormat
      ' Assign needed property values to variables.
      Dim currencySymbol As String = nfi.CurrencySymbol
      Dim symbolPrecedesIfPositive As Boolean = CBool(nfi.CurrencyPositivePattern Mod 2 = 0)
      Dim groupSeparator As String = nfi.CurrencyGroupSeparator
      Dim decimalSeparator As String = nfi.CurrencyDecimalSeparator

      ' Form regular expression pattern.
      Dim pattern As String = Regex.Escape(CStr(IIf(symbolPrecedesIfPositive, currencySymbol, ""))) + _
                              "\s*[-+]?" + "([0-9]{0,3}(" + groupSeparator + "[0-9]{3})*(" + _
                              Regex.Escape(decimalSeparator) + "[0-9]+)?)" + _
                              CStr(IIf(Not symbolPrecedesIfPositive, currencySymbol, "")) 
      Console.WriteLine("The regular expression pattern is: ")
      Console.WriteLine("   " + pattern)      

      ' Get text that matches regular expression pattern.
      Dim matches As MatchCollection = Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace)               
      Console.WriteLine("Found {0} matches. ", matches.Count)

      ' Get numeric string, convert it to a value, and add it to List object.
      Dim expenses As New List(Of Decimal)
                     
      For Each match As Match In matches
         expenses.Add(Decimal.Parse(match.Groups.Item(1).Value))      
      Next

      ' Determine whether total is present and if present, whether it is correct.
      Dim total As Decimal
      For Each value As Decimal In expenses
         total += value
      Next
      
      If total / 2 = expenses(expenses.Count - 1) Then
         Console.WriteLine("The expenses total {0:C2}.", expenses(expenses.Count - 1))
      Else
         Console.WriteLine("The expenses total {0:C2}.", total)
      End If   
   End Sub
End Module
' The example displays the following output:
'       The regular expression pattern is:
'          \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?)
'       Found 6 matches.
'       The expenses total $81.58.

Em um computador cuja cultura atual seja Inglês – Estados Unidos (en-US), o exemplo compila dinamicamente a expressão regular \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?).On a computer whose current culture is English - United States (en-US), the example dynamically builds the regular expression \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?). Esse padrão de expressão regular pode ser interpretado da seguinte maneira:This regular expression pattern can be interpreted as follows:

\$ Procure uma única ocorrência do símbolo de cifrão ($) na cadeia de caracteres de entrada.Look for a single occurrence of the dollar symbol ($) in the input string. A cadeia de caracteres do padrão de expressão regular inclui uma barra invertida para indicar que o símbolo de cifrão deve ser interpretado literalmente ao invés de como uma âncora de expressão regular.The regular expression pattern string includes a backslash to indicate that the dollar symbol is to be interpreted literally rather than as a regular expression anchor. (O símbolo $ sozinho indicaria que o mecanismo de expressões regulares deveria tentar iniciar a correspondência no final de uma cadeia de caracteres.) Para garantir que o símbolo de moeda da cultura atual não seja interpretado incorretamente como um símbolo de expressão regular, o exemplo chama o método Regex.Escape para escapar o caractere.(The $ symbol alone would indicate that the regular expression engine should try to begin its match at the end of a string.) To ensure that the current culture's currency symbol is not misinterpreted as a regular expression symbol, the example calls the Regex.Escape method to escape the character.
\s* Procure zero ou mais ocorrências de um caractere de espaço em branco.Look for zero or more occurrences of a white-space character.
[-+]? Procure zero ou uma ocorrência de um sinal de positivo ou negativo.Look for zero or one occurrence of either a positive sign or a negative sign.
([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?) Os parênteses externos ao redor da expressão a definem como um grupo de captura ou uma subexpressão.The outer parentheses around this expression define it as a capturing group or a subexpression. Se uma correspondência for localizada, informações sobre essa parte da cadeia de caracteres correspondente podem ser recuperadas do segundo objeto Group no objeto GroupCollection retornado pela propriedade Match.Groups.If a match is found, information about this part of the matching string can be retrieved from the second Group object in the GroupCollection object returned by the Match.Groups property. (O primeiro elemento na coleção representa a correspondência inteira.)(The first element in the collection represents the entire match.)
[0-9]{0,3} Procure de zero a três ocorrências dos dígitos decimais de 0 a 9.Look for zero to three occurrences of the decimal digits 0 through 9.
(,[0-9]{3})* Procure zero ou mais ocorrências de um separador de grupo seguido por três dígitos decimais.Look for zero or more occurrences of a group separator followed by three decimal digits.
\. Procure uma única ocorrência do separador decimal.Look for a single occurrence of the decimal separator.
[0-9]+ Procure por um ou mais dígitos decimais.Look for one or more decimal digits.
(\.[0-9]+)? Procure zero ou uma ocorrência de um separador decimal seguido por pelo menos um dígito decimal.Look for zero or one occurrence of the decimal separator followed by at least one decimal digit.

Se cada um desses subpadrões for encontrado na cadeia de caracteres de entrada, a correspondência será bem-sucedida, e um objeto Match que contém informações sobre a correspondência será adicionado ao objeto MatchCollection.If each of these subpatterns is found in the input string, the match succeeds, and a Match object that contains information about the match is added to the MatchCollection object.

TítuloTitle DescriçãoDescription
Linguagem de expressão regular – referência rápidaRegular Expression Language - Quick Reference Oferece informações sobre o conjunto de caracteres, operadores e constructos que você pode usar para definir expressões regulares.Provides information on the set of characters, operators, and constructs that you can use to define regular expressions.
O modelo de objeto de expressão regularThe Regular Expression Object Model Oferece informações e exemplos de código que ilustram como usar as classes de expressão regular.Provides information and code examples that illustrate how to use the regular expression classes.
Detalhes do comportamento da expressão regularDetails of Regular Expression Behavior Oferece informações sobre os recursos e o comportamento das expressões regulares do .NET.Provides information about the capabilities and behavior of .NET regular expressions.
Exemplos de expressões regularesRegular Expression Examples Oferece exemplos de código que ilustram usos típicos de expressões regulares.Provides code examples that illustrate typical uses of regular expressions.

ReferênciaReference

System.Text.RegularExpressions
System.Text.RegularExpressions.Regex
Expressões regulares - referência rápida (fazer download no formato Word)Regular Expressions - Quick Reference (download in Word format)
Expressões regulares - referência rápida (fazer download no formato PDF)Regular Expressions - Quick Reference (download in PDF format)