Validando Formulários Usando Regular Expression
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. |
|
. |
(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.
