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:
\b |
Iniciar em um limite de palavra. |
(\w+) |
Corresponde a um ou mais caracteres do word. Juntos, eles formam um grupo que pode ser chamado de \1. |
\s |
Corresponde a um caractere de espaço em branco. |
\1 |
Correspondência de substring que é igual ao grupo chamado \1. |
\b |
Corresponde a um limite de palavra. |
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:
\$ |
Procure por uma única ocorrência do símbolo de dólar ($) na seqüência de entrada. A seqüência de caracteres de padrão de expressão regular inclui uma barra invertida para indicar que o símbolo de dólar deve ser interpretada literalmente em vez de como uma âncora de expressão regular. (O símbolo $ sozinho indicam que o mecanismo de expressão regular deve tentar começar sua correspondência ao final de uma seqüência de caracteres.) Para garantir que o símbolo de moeda da cultura atual não é mal interpretado como um símbolo de expressão regular, o exemplo chama o Escape método de escape de caractere. |
\s* |
Procure por zero ou mais ocorrências de um caractere de espaço em branco. |
[-+]? |
Procure por zero ou uma de ocorrência de um sinal positivo ou de um sinal negativo. |
([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?) |
Os esta expressão entre parênteses externos definem-la como um grupo de captura ou uma subexpressão. Se uma correspondência for encontrada, informações sobre esta parte da seqüência de caracteres correspondente podem ser recuperadas da segunda Group de objeto na GroupCollection objeto retornado pela Match.Groups propriedade. (O primeiro elemento na coleção representa a correspondência de inteira.) |
[0-9]{0,3} |
Procure o zero a três ocorrências de dígitos de 0 a 9. |
(,[0-9]{3})* |
Procure por zero ou mais ocorrências de um separador de grupo seguido de três dígitos decimais. |
\. |
Procure por uma única ocorrência do separador decimal. |
[0-9]+ |
Procure um ou mais dígitos decimais. |
(\.[0-9]+)? |
Procure por zero ou uma de ocorrência do separador decimal, seguido pelo menos um dígito decimal. |
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
Título |
Descrição |
|---|---|
Fornece informações sobre o conjunto de caracteres, operadores e construtores que você pode usar para definir as expressões regulares. |
|
Práticas recomendadas para expressões regulares na.NET Framework |
Fornece recomendações para otimizar o desempenho de expressão regular e a criação de padrões de expressões regulares de robusta e confiável. |
Fornece informações e exemplos de código que ilustram como usar as classes de expressão regular. |
|
Fornece informações sobre os recursos e o comportamento de expressões regulares do .NET Framework. |
|
Fornece exemplos de código que ilustram típica usa expressões regulares. |