Compartilhar via

Expressões regulares do .NET

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:

  • Encontrar padrões de caracteres específicos.
  • Validar o texto para garantir que ele corresponde a um padrão predefinido (como um endereço de email).
  • Extrair, editar, substituir ou excluir 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, expressões regulares são uma ferramenta indispensável.

Como as expressões regulares funcionam

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 exige que o mecanismo de expressão regular seja fornecido com os dois itens de informação a seguir:

  • 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 outros recursos adicionais, como a 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 executar 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ão regular

A String classe inclui métodos de pesquisa e substituição de cadeia de caracteres que você pode usar quando deseja localizar cadeias de caracteres literais em uma cadeia de caracteres maior. Expressões regulares são mais úteis quando você deseja localizar uma das várias subcadeias de caracteres em uma cadeia de caracteres maior ou quando você 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 a RegularExpressions, causando um ataque de negação de serviço. APIs ASP.NET Core Framework que usam RegularExpressions passam um tempo limite.

Dica

O System.Web.RegularExpressions namespace contém muitos 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 em uma cadeia de caracteres, e a classe CommentRegex identifica comentários ASP.NET em uma cadeia de caracteres.

Exemplo 1: substituir substrings

Suponha que uma lista de endereçamento contenha nomes que às vezes incluem um título (Sr., Sra., Miss ou Ms.) juntamente com um nome e sobrenome. Suponha que você não queira incluir os títulos ao gerar rótulos 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.”, “Srta” ou “Srta.”. A chamada para o método Regex.Replace substitui a cadeia de caracteres correspondente por String.Empty; em outras palavras, remove a cadeia correspondente da cadeia de caracteres original.

Exemplo 2: identificar palavras duplicadas

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

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

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 faz distinção entre maiúsculas e minúsculas e o exemplo identifica a subcadeia de caracteres “This this” como uma duplicação.

A cadeia de caracteres de entrada inclui a substring "this? Isso". No entanto, devido à pontuação no meio, ela não é identificada como uma duplicação.

Exemplo 3: criar dinamicamente uma expressão regular adaptada culturalmente

O exemplo a seguir ilustra o poder das expressões regulares combinado com a flexibilidade oferecida pelos recursos de globalização do .NET. Ele usa o NumberFormatInfo objeto para determinar o formato de 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 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 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]+)?). Esse padrão de expressão regular pode ser interpretado da seguinte maneira:

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 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. O símbolo $ sozinho indicaria que o mecanismo de expressão regular 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.
\s* Procure zero ou mais ocorrências de um caractere de espaço em branco.
[-+]? Procure zero ou uma ocorrência de um sinal de positivo ou negativo.
([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?) Os parênteses externos definem essa expressão como um grupo de captura ou uma subexpressão. Se uma correspondência for encontrada, é possível recuperar as informações sobre essa parte da cadeia de caracteres correspondente a partir do segundo objeto Group dentro do objeto GroupCollection, que é retornado pela propriedade Match.Groups. O primeiro elemento na coleção representa a correspondência inteira.
[0-9]{0,3} Busque de 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 por três números decimais.
\. Procure uma única ocorrência do separador decimal.
[0-9]+ Busque um ou mais dígitos decimais.
(\.[0-9]+)? Busque zero ou uma ocorrência do separador decimal seguido por 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.

Título Descrição
Linguagem de expressões regulares – 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õ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

  • Last updated on