Expressões Regulares do .NET Framework

Expressões regulares fornecem um método poderoso, flexível e eficiente para processamento de texto. A notação extensiva de correspondência de padrões de expressões regulares permite que você rapidamente analisar grandes quantidades de texto para localizar padrões de caracteres específicos; para validar o texto para garantir que ela corresponde a um padrão predefinido (como, por exemplo, um endereço de email); para extrair, editar, substituir ou excluir texto substrings; e para adicionar as seqüências de caracteres extraídas para uma coleção para gerar um relatório. Para muitos aplicativos que lidam com seqüências de caracteres ou que analisar grandes blocos de texto, as expressões regulares são uma ferramenta indispensável.

Trabalho de expressões regulares como

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

• O padrão de expressão regular para identificar no texto.

  No.NET Framework, regular expression padrões são definidos por uma sintaxe especial ou de um idioma, o que é compatível com expressões regulares do Perl 5 e adiciona alguns recursos adicionais, como correspondência da direita para esquerda. Para obter mais informações, consulte Elementos de linguagem das expressões regulares.

• O texto a analisar o padrão de expressão regular.

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

• Determine se o padrão de expressão regular ocorre no texto de entrada, chamando o IsMatch método. Para obter um exemplo que usa o IsMatch método para validar o texto, consulte Como: Verifique se as seqüências estão em formato de email válido.

• Recuperar uma ou todas as ocorrências de texto que corresponda ao padrão de expressão regular, chamando o Match ou Matches método. O antigo método retorna um Match objeto que fornece informações sobre o texto correspondente. O último retorna um MatchCollection objeto que contém um Match o objeto para cada correspondência encontrada em texto analisado.

• Substitua o texto que corresponda ao padrão de expressão regular, chamando o Replace método. Para obter exemplos que usam o Replace método para alterar formatos de data e remova os caracteres inválidos de uma seqüência, consulte Como: Remover caracteres inválido de uma seqüência de caracteres. e Exemplo: Formatos de data de alteração.

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

Exemplos de Expressões Regulares

O String classe inclui um número de métodos de pesquisa e substituição de seqüência de caracteres que você pode usar quando desejar localizar seqüências de caracteres literais em uma seqüência de caracteres maiores. Expressões regulares são mais úteis quando você deseja localizar uma das várias substrings em uma seqüência de caracteres maior ou quando você deseja identificar padrões em uma seqüência de caracteres, conforme os exemplos a seguintes ilustram.

Exemplo 1: Substituição de Substrings

Suponha que uma lista de endereçamento contenha os nomes que às vezes incluem um título (SR., Sra, perda ou Sra.) juntamente com um nome e sobrenome. Se não desejar incluir os títulos quando você gerar etiquetas de envelope na lista, você pode usar uma expressão regular para remover os títulos, como o exemplo a seguir ilustra.

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

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

O padrão de expressão regular (Mr\.? |Mrs\.? |Miss |Ms\.? ) corresponde a qualquer ocorrência de "Mr", "do SR. " , "Srta.", "Srta. " , "Perda", "Ms ou"Ms. " . A chamada para o Regex.Replace método substitui a seqüência de caracteres correspondente com String.Empty; em outras palavras, ele remove da seqüência de caracteres original.

Exemplo 2: Identificando as palavras duplicadas

Acidentalmente, duplicar palavras é um erro comum que os autores fazem. Uma expressão regular pode ser usada para identificar palavras duplicadas, como mostra o exemplo a seguir.

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

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

O padrão de expressão regular \b(\w+?)\s\1\b pode ser interpretado da seguinte maneira:

O Regex.Matches método é chamado com a expressão regular, definir as opções para RegexOptions.IgnoreCase. Portanto, não diferencia a operação de correspondência e o exemplo identifica a subseqüência "Este este" como uma duplicação.

Observe que a seqüência de caracteres de entrada inclui a subseqüência "Este (a). Este". No entanto, devido a marca de pontuação intermediárias, ele não é identificado como uma duplicação.

Exemplo 3: Construindo dinamicamente uma expressão Regular da cultura

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

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.

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.

Em um computador cuja cultura atual é inglês - dos Estados Unidos (en-US), o exemplo cria dinamicamente a expressão regular \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?). O padrão de expressão regular pode ser interpretado da seguinte forma:

Se cada um desses subpadrões for encontrado na seqüência de entrada, a correspondência for bem-sucedida e um Match o objeto que contém informações sobre a correspondência é adicionado a MatchCollection objeto.

Tópicos relacionados

Referência

System.Text.RegularExpressions

System.Text.RegularExpressions.Regex