sexta-feira, 8 de abril de 2016

Original em http://www.devmedia.com.br

Autor: Kallebe Lins

Expressões Regulares são padrões de caracteres que associam sequências de caracteres no texto. Podemos usar expressões regulares para extrair ou substituir porções de texto, bem como, endereço ou link de imagens em uma página HTML, modificar formato de texto ou remover caracteres inválidos.

Não podemos esquecer que a sintaxe de Expressões Regulares são case-sensitive, ou seja, "abc" é diferente de "ABC".

Neste artigo apresentaremos os métodos mais utilizados da classe Regex, trabalharemos as sintaxes de referência de expressões regulares mais utilizadas, seguida de práticas e validações úteis do dia-a-dia.

1. Regex

No .NET a classe Regex representa uma expressão regular imutável. Esta classe contém diversos métodos estáticos que nos permite trabalhar com expressões regulares. Para usarmos o objeto Regex devemos importar o namespace System.Text.RegularExpressions.

Segue relação de métodos mais utilizados da classe Regex, a saber:

Métodos Regex
Framework Descrição Modelo
Escape evita um conjunto de metacaracteres (\, *, +, ?, |, {, [, (,), ^, $,., #, e espaço em branco) substiuindo ele com seu código de escape Regex.Escape( input, pattern)
IsMatch indica se a expressão regular encontrar a entrada de string associada Regex.IsMatch( input, pattern)
Regex.IsMatch( input, pattern, options)
Match pesquisa uma entrada de string para uma ocorrência de uma expressão regular e retorna resultado preciso como um objeto Match único Regex.Match( input, pattern)
Regex.Match( input, pattern, options)
Matches pesquisa uma entrada de string para todas as ocorrências de uma expressão regular e retorna todos os resultados com sucesso, executa Match várias vezes Regex.Matches( input, pattern)
Regex.Matches( input, pattern, options)
Replace dentro de uma entrada de string especificada, substitui string que associa com expressão regular por outra especificada para reposição Regex.Replace( input, pattern, replacement)
Regex.Replace( input, pattern, replacement, options)
Split divide uma string em um array de substrings nas posições definidas pela expressão regular Regex.Split( input, pattern)
Regex.Split( input, pattern, options)
Unescape substitui código de escape pelo caractere de escape Regex.Unescape( input, pattern)

Opções de Execução
Framework Caractere Inline Descrição
None N/A nenhuma opção especificada
IgnoreCase i associa case-insensitive
Multiline m modo multi-linha; modifica o significado de ^ e $, assim ele executa associando o inicio e fim, respectivamente, de alguma linha
ExplicitCapture n somente capturas validas são explicitamente grupos nomeados ou numerados do formato (?<name>...)
SingleLine s modo linha simples; modifica o significado do caractere (.) assim ele associa todos caracteres (em lugar de cada caractere exceto \n)
IgnorePatternWhitespace x permite espaço em branco e comentários no pattern
Compiled N/A expressões regulares seriam compilados para um assembly
RightToLeft N/A procura mover da direita para esquerda em lugar da esquerda para direita
Global (não contém na framework) g pesquisa global para todas as ocorrências do padrão

Regex na Prática
Framework Exemplo
IsMatch Dim newBoolean1 As Boolean = Regex.IsMatch("Editora Wrox", "wrox")
Dim newBoolean2 As Boolean = Regex.IsMatch("Editora Wrox", "wrox", _
    RegexOptions.IgnoreCase)
Dim myRegex As New Regex("wrox", RegexOptions.IgnoreCase)
Dim newBoolean3 As Boolean = myRegex.IsMatch("Editora Wrox")

Obs.: newBoolean1 retorna 'False' por causa que não contém 'IgnoreCase' (confira Opções de Execução)
Match Dim newMatch1 As Match = Regex.Match("Editora Wrox", "wrox", RegexOptions.IgnoreCase)
Response.Write(newMatch1.Success)
Matches Dim newMatches As MatchCollection = Regex.Matches("Editora Wrox", "wrox", RegexOptions.IgnoreCase)
For Each myMatch As Match In newMatches
    Response.Write(myMatch.Value)
Next
Replace Dim newString1 As String = Regex.Replace("Editora Wrox", "wrox", "o'relly")
Dim newString2 As String = Regex.Replace("Editora Wrox", "wrox", "o'relly", _
    RegexOptions.IgnoreCase)
Dim myRegex As New Regex("wrox", RegexOptions.IgnoreCase)
Dim newString3 As String = myRegex.Replace("Editora Wrox", "o'relly")
Split Dim newString1() As String = Regex.Split("Editora Wrox", "wrox", RegexOptions.IgnoreCase)
For Each str As String In newString1
    Response.Write(str & "<br />")
Next

2. Referências

Segue uma breve descrição dos caracteres especiais mais utilizados em expressão regular.

Escape
Caractere Descrição
\ caractere de escape (usado para anular um efeito de um metacaractere; TOME CUIDADO AO UTILIZAR ESTE CARACTERE POIS "\d" REPRESENTA UM METACARACTERE DÍGITO E PARA ANULAR DEVE-SE ACRESCENTAR MAIS UM CARACTERE DE ESCAPE "\\d") .
\a alarm \u0007
\b veja âncora.
\t tab \u0009
\r retorno de carro \u000D
\v tab vertical \u000B
\f alimentação de formulário \u000C
\n nova linha \u000A
\e escape \u001B
\040 caractere ASCII como octal (3 dígitos). Por exemplo, um caractere \040 representa um espaço
\x20 caractere ASCII usando representação hexadecimal (3 dígitos)
\cC caractere ASCII de controle. Por exemplo, \cC é equivalente a Ctrl-C
\u0020 caractere ASCII usando representação hexadecimal (4 dígitos)

Agrupamento
Caractere Descrição
[] usado para indicar o conjunto de caracteres que podem conter no texto pesquisado.
(veja quantificadores)
[^] usado para indicar o conjunto de caracteres que NÃO podem conter na pesquisa.
(...) indica o início e o fim de um grupo;
ex.: /(abc)+(def)/ encontra um ou mais ocorrencias de "abc" seguido por uma ocorrencia de "def".
obs.: para usar o parêntese, literalmente, utilize o caractere de escape "\ (" ou "\ )", ou ainda, "[ ( ]" ou "[ ) ]"

Âncora
Caractere Descrição Modelo Representação Explicação
^ início da linha "^abc" "abcde" associa texto que inicia com a sequência "abc", embora não "yabc".
$ fim da linha "abc$" "yzabc" associa texto que termina com a sequência "abc", embora não "abcde".
\b fronteira do caractere "car\b" "car"; "tocar" associa a fronteira da palavra "car", embora não "carburador".
\B não fronteira do caractere "car\B" "carburetor" não associa a fronteira da palavra "car", mas pode assegurar que a sequência ocorra no meio da palavra, como "carburador", embora não "tocar".
\A início da string  "\Apattern"  "patterns"  --
\Z fim da string  "pattern\Z"  "topattern"  --

Quantificadores
Caractere Descrição Modelo Representação Explicação
* zero ou mais vezes "zo*" "z" ; "zoo" o caractere que precede o asterisco pode ser repetido 0 ou mais vezes (equivalente a "{0,}")
+ uma ou mais vezes "zo+" "zo" ; "zoo" o caractere que precede o sinal de (+) pode ocorrer 1 ou mais vezes (equivalente a "{1,}")
? zero ou uma vez "do(es)?" "do" ; "does" o caractere que precede o sinal de interrogação pode ocorrer 0 ou 1 vez (equivalente a "{0,1}")
{n} n vezes "o{2}" "food" o caractere que precede o sinal pode ocorrerá n vezes
{n,} pelo menos n vezes "o{2,}" "foooood" a sequência "{0,}" é equivalente a "o*"; a sequência "{1,}" é equivalente a "o+"
{n,m} no mínimo n e no máximo m "o{1,3}" "foooood" associa aos três primeiros "ooo"; é equivalente a "o?"
. um caractere simples, exceto "\n" "o." "oa" representa um carecteres simples, exceto "\n" ( para associá-lo utilize o padrão "[\s\S] " )
[xyz] um dos caracteres que está dentro dos colchetes "[abc]" "plain" associa "a" contido na palavra "plain"
[a–z] um dos caracteres que está dentro dos colchetes "[a–z]" --- associa um dos caracteres de 'a' até 'z' em caixa baixa, lembre-se que expressões regulares são case-sensitive

Alternador
Caractere Descrição Modelo Representação Explicação
"|" (pipe) uma ou outra ocorrência "(z|f)ood" "zood" ou "food" o caractere | (pipe) representa uma ocorrência ou outra

Classes
Classe Descrição
[:digit:] dígito; equivalente a [0-9]
[:alnum] letras e números ; equivalente a [A-Za-z0-9]
[:space:] caracteres brancos ; equivalente a [ \t\n\r\f\v]
[:alpha:] letras; equivalente a [A-Za-z]
[:lower:] minúsculas; equivalente a [a-z]
[:upper:] maiúsculas; equivalente a [A-Z]
[:punct:] caracteres de pontuação; equivalente a [.,!?:...]
[:xdigit:] números hexadecimais; equivalente a [0-9A-Fa-f]
[:word:] qualquer caractere alfanumérico, mais underscore (_); equivalente a [[:alnum:]_]
[:blank:] espaço em branco e TAB; equivalente a [\t]
[:punct:] pontuação; equivalente a [!"#$%&'()*+,-./:;?@[\\\]_`{|}~]

Caracteres de Classes Predefinidos
Classe Caractere
[:digit:] \d
^[:digit] \D
[:space:] \s
^[:space:] \S
[:word:] \w
^[:word:] \W

Parâmetros BackReference
Caracteres Descrição
\number backreference que associa o conteúdo do grupo de mesmo número. Grupos são numerados iniciando de 1. Por exemplo, (.+) \1 associa 'abc abc' ou '777 777', embora não 'abc def'. O número máximo de backreferences é limitado para 9 (\1...\9).
\k<name> backreference nomeada. (http://msdn2.microsoft.com/en-us/library/ksz2azbh.aspx)

Comentário
Caractere Descrição
# insere comentário dentro da expressão

3. Praticando

É interessante criarmos uma página .aspx (ou qualquer outra hosting application que desejar) para testarmos as expressões regulares. O código abaixo facilita bastante a execução das sintaxes, inclusive dos métodos da classe Regex (veja Métodos Regex).

Protected Sub Button1_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles Button1.Click
    ' o padrão que utilizaremos será Regex.IsMatch( input, pattern)
    If (Regex.IsMatch(TextBox1.Text, "^\d+$")) Then
        Response.Write("Informação válida.")
    Else
        Response.Write("Informação inválida.")
    End If
End Sub

Perceba que o método IsMatch retorna um valor Booleano e é necessário informar, neste caso, apenas o texto e a sintaxe da expressão regular (veja Métodos Regex). Para qualquer teste que queira fazer basta colocar o pattern - sintaxe - da expressão regular e testar. Por exemplo, "^\d+$" valida somente dígitos, isso significa que se for digitado alguma coisa que não for número então retornará False. Abaixo segue uma lista de algumas das validações simples que utilizamos no dia a dia.

Validações Úteis com Expressões Regulares
Tipo de Validação Expressão
Dígito ^\d+$
Decimal ^[+-]?((\d+|\d{1,3}(\.\d{3})+)(\,\d*)?|\,\d+)$
^[-+]?([0-9]*\,[0-9]+|[0-9]+)$
Letra ^[[:alpha:]]+$
URL ^((http)|(https)|(ftp)):\/\/([\- \w]+\.)+\w{2,3}(\/ [%\-\w]+(\.\w{2,})?)*$
E-mail ^([\w\-]+\.)*[\w\- ]+@([\w\- ]+\.)+([\w\-]{2,3})$
Endereço IP \b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b
Tempo (24 horas) ^([0|1|2]{1}\d):([0|1|2|3|4|5]{1} \d)$
Data (dd/mm/aaaa) ^((0[1-9]|[12]\d)\/(0[1-9]|1[0-2])|30\/(0[13-9]|1[0-2])|31\/(0[13578]|1[02]))
\/\d{4}$
Telefone ^\(\d{3}\)-\d{4}-\d{4}$
Senha ^\w{4,10}$
^[a-zA-Z]\w{3,9}$
^[a-zA-Z]\w*\d+\w*$

3. Referências

- Microsoft Visual Basic .NET Programmer's Cookbook / by Matthew MacDonald;
- Sams Teach Yourself Regular Expressions in 10 Minutes / By Ben Forta;
- Mastering Regular Expressions, 3rd Edition / By Jeffrey E. F. Friedl;
- Beginning Regular Expressions / Andrew Watt;
- Microsoft .NET Framework 2.0 Application Development Foundation / byTony Northrup, Shawn WildermuthandBill Ryan.

0 comentários: