Validando Formulários Usando Regular Expression

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (3)  (0)

Uma expressão regular (ER) é um método formal de se especificar um padrão de texto, simplificando um pouco mais, as expressões regulares são strings especialmente formatadas, usadas para localizar padrões no texto, e podem ser úteis durante a validação informações, para que os dados estejam em um formato específico.

 

            Uma expressão regular (ER) é um método formal de se especificar um padrão de texto, simplificando um pouco mais, as expressões regulares são strings especialmente formatadas, usadas para localizar padrões no texto, e podem ser úteis durante a validação informações, para que os dados estejam em um formato específico.

 

Nesse artigo você aprenderá a utilizar e criar expressões regulares no AspNet C#. Também tomará conhecimento do significado de cada expressão, bem como o conjunto de caracteres usado na elaboração de uma expressão regular. Espero vocês no próximo artigo. Boa leitura a todos e até a próxima.

 

Requisitos Necessários

 

            Para uma melhor compreensão do artigo é indispensável que o leitor tenha conhecimento AspNet C#. Além disso disso algumas ferramentas são necessárias.

 

Visual Studio 2005/2008 ou Visual Web Developer 2005/2008.

 

Conceitos Básicos

A maioria dos formalismos provêm pelo menos três operações para construir expressões regulares. (WIKIPEDIA)

A primeira delas é a alternância, em que uma barra vertical (|) separa alternativas. Por exemplo, psicadélico|psicodélico pode casar "psicadélico" ou "psicodélico". A segunda operação é o agrupamento, em que parênteses ((, )) são usados para definir o escopo e a precedência de operadores, entre outros usos. Por exemplo, psicadélico|psicodélico e psic(a|o)délico são equivalentes e ambas descrevem "psicadélico" e "psicodélico". Por fim, a terceira operação é a quantificação (ou repetição). Um quantificador após um token (como um caractere) ou um agrupamento especifica a quantidade de vezes que o elemento precedente pode ocorrer. Os quantificadores mais comuns são ?, * e +. O ponto de interrogação indica que há zero ou uma ocorrência do elemento precedente. Por exemplo, ac?ção casa tanto "acção" quanto "ação". Já o asterisco indica que há zero ou mais ocorrências do elemento precedente. Por exemplo, ab*c casa "ac", "abc", "abbc", "abbbc", e assim por diante. Por fim, o sinal de adição indica que há uma ou mais ocorrências do elemento precedente. Por exemplo, ab+c casa "abc", "abbc", "abbbc", e assim por diante, mas não "ac". (WIKIPEDIA)

Essas construções podem ser combinadas arbitrariamente para formar expressões complexas, assim como expressões aritméticas com números e operações de adição, subtração, multiplicação e divisão. De forma geral, há diversas expressões regulares para descrever um mesmo conjunto de cadeias de caracteres. A sintaxe exata da expressão regular e os operadores disponíveis variam entre as implementações. ( WIKIPEDIA)

 

Tabela dos MetaCaracteres

Busca posicionada

Símbolo

Descrição

^

Busca somente no início da string.

$

Busca somente no fim da string.

\b

Encontra em qualquer parte da string.

\B

Encontra qualquer parte que não esteja limitada.

 

 

Literais

Símbolo

Descrição

Alfa-numérica

Todos os caracteres alfabéticos e numerais se encontram literalmente.

\\

Encontra o caractere de escape.

 

 

Classes de Caracteres

Símbolo

Descrição

[abc]

Encontra qualquer caractere que estiver dentro do grupo. Você pode usar hífen para denotar escala. Por Exemplo. [a-z] encontra qualquer letra do alfabeto. [0-9] encontra qualquer dígito.

[^abc]

Encontra qualquer caractere que não estiver dentro do grupo. O circunflexo indica que nenhum caractere deve estar na string.
Observação: O circunflexo usado dentro da classe de caractere é diferente do que denota o início da string, não se confundam. A negação aqui só é permitida dentro dos sinais.

.

(Ponto). Encontra qualquer caractere exceto o caractere de nova linha ou terminador de linha Unicode.

\w

Encontra qualquer caractere alfanumérico incluindo underscore. Equivalente a [a-zA-Z0-9_].

\W

Encontra qualquer caractere que não se encontra na classe dos alfanuméricos. Equivalente a [^a-zA-Z0-9_].

\d

Encontra qualquer dígito. Equivalente a [0-9].

\D

Encontra qualquer caractere que não seja um dígito. Equivalente a [^0-9].

\s

Encontra qualquer caractere que equivale a um espaço. Equivalente a [ abc].

\S

Encontra qualquer caractere que não equivale a um espaço. Equivalente a [^abc].

 

Repetição

Símbolo

Descrição

{x}

Encontra exatamente x ocorrência na expressão regular.

{x,}

Encontra x ou mais ocorrências na expressão regular.

{x,y}

Encontra x para y numero de ocorrências na expressão regular.

?

Encontra zero ou nenhuma ocorrência. Equivalente a {0,1}.

*

Encontra zero ou mais ocorrências. Equivalente a {0,}.

+

Encontra uma ou mais ocorrências. Equivalente a {1,}.

 

Alternação & Agrupamento

Símbolo

Descrição

( )

Agrupamento de caracteres para criar uma cláusula de condição. Pode estar aninhado.

|

Combina cláusulas de condições dentro de uma  expressão regular e então encontra qualquer uma das cláusulas. Similar à expressão "OR".


BackReferences

Símbolo

Descrição

( )\n

Encontra uma cláusula entre parênteses. n é o número de cláusulas para a esquerda da backReference.

 

 

Conhecendo o Espaço de Nomes System.Text.RegularExpressions

 

A plataforma .NET fornece várias classes para ajudar os desenvolvedores a reconhecerem e manipularem expressões regulares. A classe Regex (espaço de nomes System.Text.RegularExpressions) representa uma expressão regular imutável. Ela contém métodos estáticos que permitem o uso da classe Regex sem instanciar explicitamente objetos dessa classe. A classe Match representa os resultados de uma operação de correspondência com uma expressão regular. (DEITEL, 2006)

 

            A classe Regex fornece o método Match, que retorna um objeto da classe Match representando uma única correspondência com uma expressão regular. Regex também fornece o método Matches, que retorna todas as correspondências de uma expressão regular em uma string arbitrária e retorna um objeto MatchCollection, ou seja, um conjunto de objetos Match. (DEITEL, 2006)

 

 

            Agora que já aprendemos sobre Expressões Regulares na teoria, vamos ver na prática como isso funciona e como pode ser utilizado em uma aplicação Web. Abra o Visual Studio 2005/2008 ou Web Developer 2005/2008, crie um novo Web Site e dê o nome de ExpressoesRegulares.

 

 

            Abra o arquivo Default.aspx e adicione um controle Label e um controle Button ao formulário. Para o controle Button, adicione o evento Button1_Click conforme a listagem_01 apresentada abaixo.

 

<form id="form1" runat="server">

        <table id="table1" cellpadding="0" cellspacing="0" border="0" width="720px">

            <tr>

                <td colspan="3"><asp:Label ID="Label1" runat="server" Text="">asp:Label>td>

            tr>

            <tr>

                <td height="30px" colspan="3">td>

            tr>

            <tr>

                <td width="30%" align="right">Testar:td>

                <td> td>

                <td align="left"><asp:Button ID="Button1" runat="server" Text="Button" OnClick="Button1_Click" />td>

            tr>

        table>

    form>

 

Código exemplo: listagem_01

 

            Depois de já ter concluídas as alterações no formulário, abra o arquivo Default.aspx.cs e adicione o seguinte código, conforme a listagem_02 apresentada abaixo.

 

protected void Button1_Click(object sender, EventArgs e)

    {

        //Expressão regular que aceita somente números inteiros

        string numero = @"^\d+$";

        //ou

        string numero2 = @"^[0-9]+$";

 

        Match match = Regex.Match("10", numero2);

 

        Label1.Text = "Número inteiro inválido.
"
;

        if (match.Success)

        {

            Label1.Text = "Número inteiro válido.
"
;

        }

 

        //Expressão regular que aceita números reais

        string numeroReal = @"^\d+?(.|,\d+)$";

        //ou

        string numeroReal2 = @"^[0-9]+?(.|,[0-9]+)$";

 

        match = Regex.Match("10.456", numeroReal2);

 

        if (match.Success)

        {

            Label1.Text += "Número real válido.
"
;

        }

        else

        {

            Label1.Text += "Número real inválido.
"
;

        }

 

        //Expressao regular que valida email

        string email = @"^([\w\-]+\.)*[\w\- ]+@([\w\- ]+\.)+([\w\-]{2,3})$";

        match = Regex.Match("werison.faw@gmail.com", email);

 

        if (match.Success)

        {

            Label1.Text += "Email válido.
"
;

        }

        else

        {

            Label1.Text += "Email inválido.
"
;

        }

 

        //Expressão regular que valida telefone

        string telefone = @"^\d{2}-\d{4}-\d{4}$";

        //ou

        string telefone2 = @"^[0-9]{2}-[0-9]{4}-[0-9]{4}$";

        match = Regex.Match("14-1234-4567", telefone2);

 

        if (match.Success)

        {

            Label1.Text += "Telefone válido.
"
;

        }

        else

        {

            Label1.Text += "Telefone inválido.
"
;

        }

 

        //Expressao regular que valida cpf

        string cpf = @"^\d{3}\.?\d{3}\.?\d{3}\-?\d{2}$";

        match = Regex.Match("111.111.111-11", cpf);

 

        if (match.Success)

        {

            Label1.Text += "CPF válido.
"
;

        }

        else

        {

            Label1.Text += "CPF inválido.
"
;

        }

 

        //Expressao regular que valida cnpj

        string cnpj = @"^\d{3}.?\d{3}.?\d{3}/?\d{3}-?\d{2}$";

        match = Regex.Match("111.111.111/111-11", cnpj);

 

        if (match.Success)

        {

            Label1.Text += "CNPJ válido.
"
;

        }

        else

        {

            Label1.Text += "CNPJ inválido.
"
;

        }

 

        //Expressao regular que valida data

        string data = @"^((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}$";

        match = Regex.Match("01/01/2000", data);

 

        if (match.Success)

        {

            Label1.Text += "Data válida.
"
;

        }

        else

        {

            Label1.Text += "Data inválida.
"
;

        }

 

        //Expressao regular que valida cep

        string cep = @"^\d{5}\-?\d{3}$";

        match = Regex.Match("09740-001", cep);

 

        if (match.Success)

        {

            Label1.Text += "CEP válido.
"
;

        }

        else

        {

            Label1.Text += "Cep inválido.
"
;

        }

 

        //Expressao regular que valida url

        string url = @"^((http)|(https)|(ftp)):\/\/([\- \w]+\.)+\w{2,3}(\/ [%\-\w]+(\.\w{2,})?)*$";

        match = Regex.Match("http://neocanvas.aspbrasil.net", url);

 

        if (match.Success)

        {

            Label1.Text += "URL válida.
"
;

        }

        else

        {

            Label1.Text += "URL inválida.
"
;

        }

 

        //Expressao regular que valida ip

        string ip = @"^\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b$";

        match = Regex.Match("127.0.0.0", ip);

 

        if (match.Success)

        {

            Label1.Text += "IP válido.
"
;

        }

        else

        {

            Label1.Text += "IP inválido.
"
;

        }

 

        //Expressao regular que valida nomes

        string nome = @"^([\'\.\^\~\´\`\\áÁ\\àÀ\\ãÃ\\âÂ\\éÉ\\èÈ\\êÊ\\íÍ\\ìÌ\\óÓ\\òÒ\\õÕ\\ôÔ\\úÚ\\ùÙ\\çÇaA-zZ]+)+((\s[\'\.\^\~\´\`\\áÁ\\àÀ\\ãÃ\\âÂ\\éÉ\\èÈ\\êÊ\\íÍ\\ìÌ\\óÓ\\òÒ\\õÕ\\ôÔ\\úÚ\\ùÙ\\çÇaA-zZ]+)+)?$";

        //ou

        string nome2 = @"^[aA-zZ]+((\s[aA-zZ]+)+)?$";

        match = Regex.Match("werison aparecido fernandes", nome2);

 

        if (match.Success)

        {

            Label1.Text += "Nome válido.
"
;

        }

        else

        {

            Label1.Text += "Nome inválido.
"
;

        }

    }

 

            Antes que você queira começar a testar o código acima, vamos entender o que faz cada um dos métodos utilizados, bem como as expressões regulares construídas.

 

Regex.Match(string input, string pattern);

@param = string input: O valor de entrada a ser validado. Exemplo: cep:09841-000.

@param= string pattern: A expressão a ser testada. Exemplo: cep: @"^\d{5}\-?\d{3}$".

@return=  Match: Objeto da classe Match que define um conjunto de métodos e atributos para a manipulação de expressões regulares.

 

Regex.Match(string input, string pattern);

match.Success

@return= bool: Retorna um valor booleano indicando se o teste Match foi bem-sucedido. Exemplo: true.

 

Entendendo as Expressões Regulares

 

string numero = @"^\d+$"

 

^: Indica o começo da linha. Caso seja omitido esse caractere, será permitida a entrada de qualquer tipo de caractere no início da expressão. Exemplo: w\?;.,io12306, nesse caso seria uma expressão válida.

 \d+: Permite somente números. A barra invertida escapa o caractere d. Caso seja omitida, significa que estará permitindo sucessivamente várias ocorrências da letra “d” e não números. Exemplo: dddd.

+: Permite várias ocorrências de um caractere ou pelo menos uma ocorrência.

$: indica o final da linha. Caso seja omitido esse caractere, será permitida a entrada de qualquer tipo de caractere no final da expressão. Exemplo:12345we.,?/;t, nesse caso seria uma expressão válida.

 

//ou

string numero2 = @"^[0-9]+$"

           

            A diferença entre a primeira expressão e a segunda é a ocorrência da seqüência de caracteres [0-9].

[0-9]: Tem o mesmo efeito que \d, ou seja, permite apenas números. Nesse caso pode ser informado explicitamente todos os caracteres válidos na expressão. Exemplo: [0,1,2,3,4,5,6,7,8,9]. Pode ser informado implicitamente como a expressão que estamos estudando [0-9]. O sinal indica a condição de sequência, onde é informado o primeiro e o útlimo caractere da sequência e o sistema se encarrega de mapear o intervalo.

 

string numeroReal = @"^\d+?(.|,\d+)$"

//ou

string numeroReal2 = @"^[0-9]+?(.|,[0-9]+)$"

 

?: Indica que tudo que estiver depois na expressão é opcional.

(.|,[0-9]+): Assim como na matemática os parênteses servem para agrupar expressões.

.|,: O pipe na expressão tem o significado do ou lógico, ou seja, tanto o que tiver a direita ou a esquerda da expressão pode ocorrer, sendo uma ocorrência por vez.

 

string email = @"^([\w\-]+\.)*[\w\- ]+@([\w\- ]+\.)+([\w\-]{2,3})$"

 

\w: Permite a entrada de qualquer caratere alfanumérico incluindo underscore.

\-: Permite a entrada do caractere -.

\.: Permite a entrada do caractere ..

*: Permite zero ou várias ocorrências de tudo que está a esquerda desse caractere na expressão.

@: Obriga a ocorrência desse caractere na expressão.

{2,3}: Permite x ocorrências de tudo que está a esquerda desse conjunto na expressão, onde x é o número indicado entre {}, nesse caso 2 ou 3.

 

string telefone = @"^\d{2}-\d{4}-\d{4}$";

//ou

string telefone2 = @"^[0-9]{2}-[0-9]{4}-[0-9]{4}$";

 

            Não há nada diferente do que já foi explicado anteriormente.

           

string cpf = @"^\d{3}\.?\d{3}\.?\d{3}\-?\d{2}$";

 

      Não há nada diferente do que já foi explicado anteriormente.

 

 

string cnpj = @"^\d{3}.?\d{3}.?\d{3}/?\d{3}-?\d{2}$";

 

Não há nada diferente do que já foi explicado anteriormente.

 

string data = @"^((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}$";

 

0[1-9]: Permite a ocorrência do caractere 0 seguido de um caratere que pode variar de 1-9. Exemplo: 01, 09.

[12]\d: Permite a ocorrência de do caractere 1 ou 2 [12] seguido de um número que pode variar de 0-9.

\/: Escapa o caractere barra normal.

1[0-2]): Permite a ocorrência do caractere 1 seguido dos caracteres 0, 1, 2. Uma ocorrência por vez.

0[13-9]: Permite a ocorrência do caractere 0 seguido dos caractes 1 ou 3, ou ainda a sequência dos caracteres que podem variar de 4-9. Exemplo: 01, 03, 04; 09 são aceitos. Observação 02 não será aceito.

 

string cep = @"^\d{5}\-?\d{3}$";

 

            Não há nada diferente do que já foi explicado anteriormente.

 

string url = @"^((http)|(https)|(ftp)):\/\/([\- \w]+\.)+\w{2,3}(\/[%\-\w]+(\.\w{2,})?)*$";

 

            Não há nada diferente do que já foi explicado anteriormente.

 

string nome = "^([\'\.\^\~\´\`\\áÁ\\àÀ\\ãÃ\\âÂ\\éÉ\\èÈ\\êÊ\\íÍ\\ìÌ\\óÓ\\òÒ\\õÕ\\ôÔ\\úÚ\\ùÙ\\çÇaA-zZ]+)+((\s[\'\.\^\~\´\`\\áÁ\\àÀ\\ãÃ\\âÂ\\éÉ\\èÈ\\êÊ\\íÍ\\ìÌ\\óÓ\\òÒ\\õÕ\\ôÔ\\úÚ\\ùÙ\\çÇaA-zZ]+)+)?$";

//ou

string nome2 = @"^[aA-zZ]+((\s[aA-zZ]+)+)?$"

 

"([\'\.\^\~\´\`\\áÁ\\àÀ\\ãÃ\\âÂ\\éÉ\\èÈ\\êÊ\\íÍ\\ìÌ\\óÓ\\òÒ\\õÕ\\ôÔ\\úÚ\\ùÙ\\çÇaA-zZ]+): Permite a ocorrência de todas as letras do alfabeto em caixa alta e em caixa baixa (aA-zZ). Os demais caracteres na expressão causam a excessão, que neste caso se faz necessário porque a expressão (aA-zZ), não permite caracteres acentuados.

\s: Permite o caractere espaço “ “ na expressão.

 

            Agora que já entendemos o funcionamento de cada uma das expressões apresentadas, vamos testar nossa aplicação. Você pode ainda entrar com novos valores, para testar novas situações ainda não testar. Rode a aplicação e veja os resultados. Observe se você obteve os mesmos resultados apresentados na figura abaixo.

 

                       

 

 

            Espero que vocês tenham gostado desse artigo. Um grande abraço a todos e até a próxima.

 

 

Referências Bibliográficas

 

[DEITEL P., DEITEL J. 2006] DEITEL P., DEITEL J. C# Como Programar. São Paulo: Editora Person Makron books, 2006. P. 572

 

[WIKIPEDIA] WIKIPEDIA, http://pt.wikipedia.org/wiki/Express%C3%A3o_regular, acessado em 04/03/2009.

 

 

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?