Partilhar via

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-lhe processar rapidamente grandes quantidades de texto para:

  • Localizar padrões de carateres específicos.
  • Valide o texto para garantir que corresponde a um padrão predefinido (como um endereço de e-mail).
  • Extrair, editar, substituir ou eliminar subcadeias 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 objeto System.Text.RegularExpressions.Regex 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 classe Regex permitem executar as seguintes operações:

Para obter uma visão geral do modelo de objeto de expressão regular, consulte The Regular Expression Object Model.

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 classe String 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.

Advertência

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 RegularExpressions, causando um ataque de negação de serviço . APIs da estrutura ASP.NET Core que usam RegularExpressions implementam um tempo limite.

Sugestão

O namespace System.Web.RegularExpressions 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 classe TagRegex identifica marcas de início numa string, e a classe CommentRegex identifica comentários em ASP.NET numa string.

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 de expressão regular (Mr\.? |Mrs\.? |Miss |Ms\.? ) corresponde a qualquer ocorrência de "Sr.", "Sr.", "Sra.", "Sra.", "Senhorita", "Sra.", ou "Senhora". A chamada para o método Regex.Replace substitui a cadeia de caracteres correspondente por String.Empty; em outras palavras, ele o remove da cadeia de caracteres 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($"{match.Value} (duplicates '{match.Groups[1].Value}') at position {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 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 Fazer corresponder a substring que seja igual ao grupo denominado \1.
\b Corresponder a um limite de palavras.

O método Regex.Matches é 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 pelas funcionalidades de globalização do .NET. Ele usa o objeto NumberFormatInfo 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 sequência numérica, converte-a em um valor Decimal e calcula um total acumulado.

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 {matches.Count} matches.");

      // 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 {expenses[expenses.Count - 1]:C2}.");
      else
         Console.WriteLine($"The expenses total {total:C2}.");
   }
}
// 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 constrói dinamicamente a expressão regular \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?). 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 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 mal interpretado como um símbolo de expressão regular, o exemplo chama o método Regex.Escape para escapar do caractere.
\s* Procure zero ou mais ocorrências de um caractere de espaço em branco.
[-+]? Procure observar 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 objeto Group no objeto GroupCollection retornado pela propriedade Match.Groups. O primeiro elemento da coleção representa toda a correspondência.
[0-9]{0,3} Procure entre zero e três ocorrências dos dígitos decimais de 0 a 9.
(,[0-9]{3})* Busque zero ou mais ocorrências de um separador de grupo seguido de três algarismos.
\. Procure uma única ocorrência do separador decimal.
[0-9]+ Procure um ou mais dígitos decimais.
(\.[0-9]+)? Procura por 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 objeto Match que contém informações sobre a correspondência será adicionado ao objeto MatchCollection.

Título Descrição
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 das Expressões Regulares Fornece informações sobre os recursos e o comportamento de expressões regulares do .NET.
Usar expressões regulares no Visual Studio

Referência