Expressões regulares do .NET

  • Artigo

As expressões regulares fornecem um método poderoso, flexível e eficiente para processar texto. A extensa notação de correspondência de padrões de expressões regulares permite que você analise rapidamente grandes quantidades de texto para:

  • Encontre padrões de caracteres específicos.
  • Valide o texto para garantir que ele corresponda a um padrão predefinido (como um endereço de e-mail).
  • Extraia, edite, substitua ou exclua substrings de texto.
  • Adicione cadeias de caracteres extraídas a uma coleção para gerar um relatório.

Para muitos aplicativos que lidam com cadeias de caracteres ou que analisam grandes blocos de texto, as expressões regulares são uma ferramenta indispensável.

Como funcionam as expressões regulares

A peça central do processamento de texto com expressões regulares é o mecanismo de expressão regular, que é representado pelo System.Text.RegularExpressions.Regex objeto no .NET. No mínimo, o processamento de texto usando expressões regulares requer que o mecanismo de expressão regular seja fornecido com os seguintes dois itens de informação:

  • O padrão de expressão regular a ser identificado no texto.

    No .NET, os padrões de expressão regular são definidos por uma sintaxe ou linguagem especial, que é compatível com expressões regulares Perl 5 e adiciona alguns recursos adicionais, como correspondência da direita para a esquerda. Para obter mais informações, consulte Linguagem de expressão regular - referência rápida.

  • O texto a ser analisado para o padrão de expressão regular.

Os métodos da Regex classe permitem que você execute as seguintes operações:

Para obter uma visão geral do modelo de objeto de expressão regular, consulte O modelo de objeto de expressão regular.

Para obter mais informações sobre a linguagem de expressão regular, consulte Linguagem de expressão regular - referência rápida ou baixe e imprima um dos seguintes folhetos:

Exemplos de expressões regulares

A String classe inclui métodos de pesquisa e substituição de cadeia de caracteres que você pode usar quando quiser localizar cadeias de caracteres literais em uma cadeia de caracteres maior. As expressões regulares são mais úteis quando você deseja localizar uma das várias substrings em uma cadeia de caracteres maior ou quando deseja identificar padrões em uma cadeia de caracteres, como ilustram os exemplos a seguir.

Aviso

Ao usar System.Text.RegularExpressions para processar entradas não confiáveis, passe um tempo limite. Um usuário mal-intencionado pode fornecer entrada para RegularExpressionso , causando um ataque de Negação de Serviço. ASP.NET APIs da estrutura principal que usam RegularExpressions passar um tempo limite.

Gorjeta

O System.Web.RegularExpressions namespace contém vários objetos de expressão regular que implementam padrões de expressão regular predefinidos para analisar cadeias de caracteres de documentos HTML, XML e ASP.NET. Por exemplo, a TagRegex classe identifica marcas de início em uma cadeia de caracteres e a CommentRegex classe identifica ASP.NET comentários em uma cadeia de caracteres.

Exemplo 1: Substituir substrings

Suponha que uma lista de discussão contenha nomes que às vezes incluem um título (Sr., Sra., Miss, ou Sra.) juntamente com um nome e sobrenome. Suponha que você não queira incluir os títulos ao gerar etiquetas de envelope da lista. Nesse caso, você pode usar uma expressão regular para remover os títulos, como ilustra o exemplo a seguir:

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 (Mr\.? |Mrs\.? |Miss |Ms\.? ) de expressão regular corresponde a qualquer ocorrência de "Sr.", "Sr.", "Sra.", "Sra.", "Senhorita", "Sra.", ou "Senhora". A chamada para o Regex.Replace método substitui a string correspondente por String.Empty; em outras palavras, ele a remove da string original.

Exemplo 2: Identificar palavras duplicadas

A duplicação acidental de palavras é um erro comum que os escritores cometem. Use uma expressão regular para identificar palavras duplicadas, como mostra o exemplo a seguir:

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 \b(\w+?)\s\1\b de expressão regular pode ser interpretado da seguinte forma:

Padrão Interpretação
\b Comece com um limite de palavras.
(\w+?) Corresponder a um ou mais caracteres de palavras, mas o menor número possível de caracteres. Juntos, eles formam um grupo que pode ser referido como \1.
\s Corresponder a um caractere de espaço em branco.
\1 Corresponder a substring que é igual ao grupo chamado \1.
\b Corresponder a um limite de palavras.

O Regex.Matches método é chamado com opções de expressão regular definidas como RegexOptions.IgnoreCase. Portanto, a operação de correspondência não diferencia maiúsculas de minúsculas e o exemplo identifica a substring "This this" como uma duplicação.

A string de entrada inclui a substring "this? Isto". No entanto, devido ao sinal de pontuação interveniente, não é identificado como uma duplicação.

Exemplo 3: Criar dinamicamente uma expressão regular sensível à cultura

O exemplo a seguir ilustra o poder das expressões regulares combinado com a flexibilidade oferecida pelo . Recursos de globalização da NET. Ele usa o NumberFormatInfo objeto para determinar o formato dos valores de moeda na cultura atual do sistema. Em seguida, ele usa essas informações para construir dinamicamente uma expressão regular que extrai valores de moeda do texto. Para cada correspondência, ele extrai o subgrupo que contém apenas a cadeia de caracteres numérica, converte-a em um Decimal valor e calcula um total em execução.

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 é Inglês - Estados Unidos (en-US), o exemplo cria dinamicamente a expressão \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?)regular . Este padrão de expressão regular pode ser interpretado da seguinte forma:

Padrão Interpretação
\$ Procure uma única ocorrência do símbolo de dólar ($) na cadeia de caracteres de entrada. A cadeia de caracteres de padrão de expressão regular inclui uma barra invertida para indicar que o símbolo do dólar deve ser interpretado literalmente em vez de como uma âncora de expressão regular. O $ símbolo por si só indicaria que o mecanismo de expressão regular deve tentar iniciar sua 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 Regex.Escape método para escapar do caractere.
\s* Procure zero ou mais ocorrências de um caractere de espaço em branco.
[-+]? Procure zero ou uma ocorrência de um sinal positivo ou negativo.
([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?) Os parênteses externos definem esta expressão como um grupo de captura ou uma subexpressão. Se uma correspondência for encontrada, as informações sobre essa parte da cadeia de caracteres correspondente poderão ser recuperadas do segundo Group objeto no GroupCollection objeto retornado pela Match.Groups propriedade. O primeiro elemento da coleção representa toda a correspondência.
[0-9]{0,3} Procure zero a três ocorrências dos dígitos decimais de 0 a 9.
(,[0-9]{3})* Procure zero ou mais ocorrências de um separador de grupo seguido de três dígitos decimais.
\. Procure uma única ocorrência do separador decimal.
[0-9]+ Procure um ou mais dígitos decimais.
(\.[0-9]+)? Procure zero ou uma ocorrência do separador decimal seguido de pelo menos um dígito decimal.

Se cada subpadrão for encontrado na cadeia de caracteres de entrada, a correspondência será bem-sucedida e um Match objeto que contém informações sobre a correspondência será adicionado ao MatchCollection objeto.

Title Description
Linguagem de Expressão Regular - Referência Rápida Fornece informações sobre o conjunto de caracteres, operadores e construções que você pode usar para definir expressões regulares.
O modelo de objeto de expressão regular Fornece informações e exemplos de código que ilustram como usar as classes de expressão regular.
Detalhes do comportamento de expressão regular Fornece informações sobre os recursos e o comportamento de expressões regulares do .NET.
Usar expressões regulares no Visual Studio

Referência