Expressão regular de validação de email

14 de julho de 2006 12 respostas

carneiro 14 de julho de 2006

Pessoal,

Conhecem alguma expressão regular massa pra validar email? Não vai ser javascript, vai ser validação do lado do servidor.

Obrigado,

12 Respostas

cassio 14 de jul. de 2006

String regex = "[A-Za-z0-9\\._-]+@[A-Za-z]+\\.[A-Za-z]+";
String email = "[email removido]";
boolean ok = email.matches(regex);

Acho que algo assim deve funcionar. Tem que ver extamente quais caracteres você permite no endereço… underline, hífem, ponto, etc… O meu exemplo está permitindo todos estes… Mas eu ainda não testei isso não! Só escrevi aqui direto

Falou!

paulovittor23 21 de set. de 2006

/* **********************************************************************************************

ValidaEmail(email, required)
@author: Paulo Vitor @date: 21/03/2006

Verifica se a string possui o formato /^\w+([.-]?\w+)@\w+([.-]?\w+)(.\w{1,3})+$/
********************************************************************************************/
function ValidaEmail(obj, required) {
if (required == undefined)required=true; //se não for especificado, assume que é obrigatório
if (obj == null)return(!required); //se o e-mail for nulo mas não for obrigatório retorna 1
if (obj.value.length==0)return(!required); //se o campo estiver vazio mas não for obrigatório retorna 1
return(/^\w+([.-]?\w+)@\w+([.-]?\w+)(.\w{1,3})+$/.test(obj.value));//retorna true se a regra for obdecida
}

carneiro 21 de set. de 2006

galera, eu adotei a biblioteca validateEmail.js que vem no commons-validator do Struts. Bem legal e completa.

Grato!

apo 21 de set. de 2006

paulovittor23:
/* **********************************************************************************************

ValidaEmail(email, required)

@author: Paulo Vitor @date: 21/03/2006

Verifica se a string possui o formato /^\w+([.-]?\w+)@\w+([.-]?\w+)(.\w{1,3})+$/

********************************************************************************************/
function ValidaEmail(obj, required) {
if (required == undefined)required=true; //se não for especificado, assume que é obrigatório
if (obj == null)return(!required); //se o e-mail for nulo mas não for obrigatório retorna 1
if (obj.value.length==0)return(!required); //se o campo estiver vazio mas não for obrigatório retorna 1
return(/^\w+([.-]?\w+)@\w+([.-]?\w+)(.\w{1,3})+$/.test(obj.value));//retorna true se a regra for obdecida
}

Isso é javascript

iktuz 7 de mai. de 2007

Montei esta:

package test;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Expressao {

    private String[] wrongNames() {
        return new String[] { "-iktuz", "_iktuz", ".iktuz", "--iktuz", "__iktuz",
                "..iktuz", "iktuz-", "iktuz_", "iktuz.", "iktuz--", "iktuz__",
                "iktuz..", "iktuz-iktuz-", "iktuz_iktuz_", "iktuz.iktuz.", "123iktuz",
                "iktuz.-", "iktuz_-" };
    }

    private String[] rightNames() {
        return new String[] { "iktuz", "iktuz.iktuz", "iktuz.iktuz.iktuz",
                "iktuz-iktuz", "iktuz-iktuz-iktuz", "iktuz_iktuz", "iktuz_iktuz_iktuz",
                "iktuz-123", "iktuz_123", "iktuz.123", "iktuz.iktuz-iktuz_iktuz",
                "iktuz123" };
    }

    private String[] wrongDomains() {
        return new String[] { "domain", "-domain", ".domain", "_domain",
                "domain-", "domain.", "domain_" };
    }

    private String[] rightDomains() {
        return new String[] { "domain.com", "domain.com.br", "do-main.com",
                "do-main.com.br", "domain123.com", "domain123.com.br" };
    }

    private void show(String[] values, String mask) {
        Pattern pattern = Pattern.compile(mask);
        for (int i = 0; i < values.length; i++) {
            Matcher matcher = pattern.matcher(values[i]);
            System.out.println(values[i] + " : " + matcher.matches());
        }
        System.out.println("+---------------------------------------+");
    }

    private void show(String[] values, String[] values2, String mask) {
        Pattern pattern = Pattern.compile(mask);
        String email;
        for (int i = 0; i < values.length; i++) {
            for (int j = 0; j < values2.length; j++) {
                email = values[i] + '@' + values2[j];
                Matcher matcher = pattern.matcher(email);
                System.out.println(email + " : " + matcher.matches());
                
                matcher = pattern.matcher(email.toUpperCase());
                System.out.println(email.toUpperCase() + " : " + matcher.matches());
            }
        }
        System.out.println("+---------------------------------------+");
    }

    private void start() {
        String nameMask = "[a-zA-Z]+[a-zA-Z0-9]*([\\.|\\-|_][a-zA-Z0-9]+)*";
        // show(wrongNames(), nameMask);
        // show(rightNames(), nameMask);

        String domainMask = "[a-zA-Z]+[a-zA-Z0-9]*([\\.|\\-|_][a-zA-Z0-9]+)+";
        // show(wrongDomains(), domainMask);
        // show(rightDomains(), domainMask);

        String at = "@";
        String emailMask = nameMask + at + domainMask;
        show(rightNames(), rightDomains(), emailMask);
        show(rightNames(), wrongDomains(), emailMask);
        show(wrongNames(), wrongDomains(), emailMask);
    }
    public static void main(String[] args) {
        new Expressao().start();
    }
}

Se alguém encontrar algum caso que não esteja sendo previsto avise para que possamos incrementar a robustez.

Grato, T+

RaphaelSantos 16 de jun. de 2007

iktuz:

Montei esta:

package test;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Expressao {

    private String[] wrongNames() {
        return new String[] { "-iktuz", "_iktuz", ".iktuz", "--iktuz", "__iktuz",
                "..iktuz", "iktuz-", "iktuz_", "iktuz.", "iktuz--", "iktuz__",
                "iktuz..", "iktuz-iktuz-", "iktuz_iktuz_", "iktuz.iktuz.", "123iktuz",
                "iktuz.-", "iktuz_-" };
    }

    private String[] rightNames() {
        return new String[] { "iktuz", "iktuz.iktuz", "iktuz.iktuz.iktuz",
                "iktuz-iktuz", "iktuz-iktuz-iktuz", "iktuz_iktuz", "iktuz_iktuz_iktuz",
                "iktuz-123", "iktuz_123", "iktuz.123", "iktuz.iktuz-iktuz_iktuz",
                "iktuz123" };
    }

    private String[] wrongDomains() {
        return new String[] { "domain", "-domain", ".domain", "_domain",
                "domain-", "domain.", "domain_" };
    }

    private String[] rightDomains() {
        return new String[] { "domain.com", "domain.com.br", "do-main.com",
                "do-main.com.br", "domain123.com", "domain123.com.br" };
    }

    private void show(String[] values, String mask) {
        Pattern pattern = Pattern.compile(mask);
        for (int i = 0; i < values.length; i++) {
            Matcher matcher = pattern.matcher(values[i]);
            System.out.println(values[i] + " : " + matcher.matches());
        }
        System.out.println("+---------------------------------------+");
    }

    private void show(String[] values, String[] values2, String mask) {
        Pattern pattern = Pattern.compile(mask);
        String email;
        for (int i = 0; i < values.length; i++) {
            for (int j = 0; j < values2.length; j++) {
                email = values[i] + '@' + values2[j];
                Matcher matcher = pattern.matcher(email);
                System.out.println(email + " : " + matcher.matches());
                
                matcher = pattern.matcher(email.toUpperCase());
                System.out.println(email.toUpperCase() + " : " + matcher.matches());
            }
        }
        System.out.println("+---------------------------------------+");
    }

    private void start() {
        String nameMask = "[a-zA-Z]+[a-zA-Z0-9]*([\\.|\\-|_][a-zA-Z0-9]+)*";
        // show(wrongNames(), nameMask);
        // show(rightNames(), nameMask);

        String domainMask = "[a-zA-Z]+[a-zA-Z0-9]*([\\.|\\-|_][a-zA-Z0-9]+)+";
        // show(wrongDomains(), domainMask);
        // show(rightDomains(), domainMask);

        String at = "@";
        String emailMask = nameMask + at + domainMask;
        show(rightNames(), rightDomains(), emailMask);
        show(rightNames(), wrongDomains(), emailMask);
        show(wrongNames(), wrongDomains(), emailMask);
    }
    public static void main(String[] args) {
        new Expressao().start();
    }
}

Se alguém encontrar algum caso que não esteja sendo previsto avise para que possamos incrementar a robustez.

Grato, T+

amigo, ahcei muito interessante seu algoritmo,
aproveitei e fui ler a API do java pra entender melhor e entendi coisas que ficava voando. como a-zA-Z…
porem uma coisa que nao entendi nem a pau foi a função do sinal de soma, subtração e multiplicação como no caso de nome e dominio, que basicamente diferencia no final no sinal de + e o outro no sinal de *…
poderia explicar essa aqui tb [\.|\-|_] ???

rverli 26 de dez. de 2008

Bom dia,

Preciso de uma expressão simples que valide se um email tem um certo domínio. Ex: blablabla@telemar.com.br

Se alguém puder me ajudar agradeço …

Cassio_Tessaro 26 de set. de 2009

Eita esse Post é antigo mas pra quem esta procurando na internet como eu e acabei parando aqui… la vai um codigo bem, mas bem simples de validação.

Pattern padrao = Pattern.compile("[a-zA-Z0-9]+[a-zA-Z0-9_.-]+@{1}[a-zA-Z0-9_.-]*\\.+[a-z]{2,4}");
/*
* Aceita palavras que comecem de a ate z maiúsculo ou minusculo 
* Depois aceita de a ate z e alguns caracteres especiais como . _ e -
* Aceita um único @
* Por fim tem que ter de 2 a 4 letras no final da palavra
*/

Espero que isso ajude o pessoal que ta começando e que precisa de alguma referencia assim como eu.
Esse código é bem simples mas ja da pra fazer uma validação em um email.

Segue referencias :
http://java.sun.com/j2se/1.4.2/docs/api/java/util/regex/Pattern.html

Valeu e um abraço a todos!

jemoliveira 14 de out. de 2009 1 like

Cássio Tessaro:
Eita esse Post é antigo mas pra quem esta procurando na internet como eu e acabei parando aqui… la vai um codigo bem, mas bem simples de validação.
Pattern padrao = Pattern.compile("[a-zA-Z0-9]+[a-zA-Z0-9_.-]+@{1}[a-zA-Z0-9_.-]*\\.+[a-z]{2,4}");
/*
* Aceita palavras que comecem de a ate z maiúsculo ou minusculo 
* Depois aceita de a ate z e alguns caracteres especiais como . _ e -
* Aceita um único @
* Por fim tem que ter de 2 a 4 letras no final da palavra
*/
Espero que isso ajude o pessoal que ta começando e que precisa de alguma referencia assim como eu.
Esse código é bem simples mas ja da pra fazer uma validação em um email.

Segue referencias :
http://java.sun.com/j2se/1.4.2/docs/api/java/util/regex/Pattern.html

Valeu e um abraço a todos!

estou com esse problema tambem…tenho essa validação, mais e se tiver dois destinatarios para eu mandar
se ele aceita só uma arroba não vai funcionar…sabe como posso solucionar esse caso???

cmr 2 de dez. de 2009

Consegui resolver com o seguinte método:

private void validarEmail(String email) throws PlcException {

        String[] listaEmails = null;

        //Verifica se existe uma lista e de email seprada por "," ou ";"
        if(email.split(";").length &gt; 1)
            listaEmails = email.split(";");
        else  if(email.split(",").length &gt; 1)
            listaEmails = email.split(",");

        //Valida todos emails separados por ";" ou ","
        if (listaEmails != null ){
            for(int i=0; i&lt; listaEmails.length; i++){
                Pattern p = Pattern.compile("^[\\w-]+(\\.[\\w-]+)*@([\\w-]+\\.)+[a-zA-Z]{2,3}$");  
                Matcher m = p.matcher(listaEmails[i].trim()); 
                if (!m.find())
                    System.out.println("### EMAIL INVÁLIDO");
                  
            }

        
        //Valida o email sozinho
        }else{
            Pattern p = Pattern.compile("^[\\w-]+(\\.[\\w-]+)*@([\\w-]+\\.)+[a-zA-Z]{2,3}$");  
            Matcher m = p.matcher(email.trim()); 
            if (!m.find())
                System.out.println("### EMAIL INVÁLIDO");

        }

A expressão regular eu peguei deste post: http://www.guj.com.br/posts/list/23478.java

RodReis 8 de ago. de 2013

cassio:
String regex = "[A-Za-z0-9\\._-]+@[A-Za-z]+\\.[A-Za-z]+"; String email = "[email removido]"; boolean ok = email.matches(regex);

Acho que algo assim deve funcionar. Tem que ver extamente quais caracteres você permite no endereço… underline, hífem, ponto, etc… O meu exemplo está permitindo todos estes… Mas eu ainda não testei isso não! Só escrevi aqui direto

Falou!

Fiz uma modificação para funcionar redondo:

String regex = "[A-Za-z0-9\\._-]+@[A-Za-z0-9]+(\\.[A-Za-z]+)*";

Leandro_Hung 22 de mai. de 2015

iktuz:

Montei esta:

package test;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Expressao {

    private String[] wrongNames() {
        return new String[] { "-iktuz", "_iktuz", ".iktuz", "--iktuz", "__iktuz",
                "..iktuz", "iktuz-", "iktuz_", "iktuz.", "iktuz--", "iktuz__",
                "iktuz..", "iktuz-iktuz-", "iktuz_iktuz_", "iktuz.iktuz.", "123iktuz",
                "iktuz.-", "iktuz_-" };
    }

    private String[] rightNames() {
        return new String[] { "iktuz", "iktuz.iktuz", "iktuz.iktuz.iktuz",
                "iktuz-iktuz", "iktuz-iktuz-iktuz", "iktuz_iktuz", "iktuz_iktuz_iktuz",
                "iktuz-123", "iktuz_123", "iktuz.123", "iktuz.iktuz-iktuz_iktuz",
                "iktuz123" };
    }

    private String[] wrongDomains() {
        return new String[] { "domain", "-domain", ".domain", "_domain",
                "domain-", "domain.", "domain_" };
    }

    private String[] rightDomains() {
        return new String[] { "domain.com", "domain.com.br", "do-main.com",
                "do-main.com.br", "domain123.com", "domain123.com.br" };
    }

    private void show(String[] values, String mask) {
        Pattern pattern = Pattern.compile(mask);
        for (int i = 0; i < values.length; i++) {
            Matcher matcher = pattern.matcher(values[i]);
            System.out.println(values[i] + " : " + matcher.matches());
        }
        System.out.println("+---------------------------------------+");
    }

    private void show(String[] values, String[] values2, String mask) {
        Pattern pattern = Pattern.compile(mask);
        String email;
        for (int i = 0; i < values.length; i++) {
            for (int j = 0; j < values2.length; j++) {
                email = values[i] + '@' + values2[j];
                Matcher matcher = pattern.matcher(email);
                System.out.println(email + " : " + matcher.matches());
                
                matcher = pattern.matcher(email.toUpperCase());
                System.out.println(email.toUpperCase() + " : " + matcher.matches());
            }
        }
        System.out.println("+---------------------------------------+");
    }

    private void start() {
        String nameMask = "[a-zA-Z]+[a-zA-Z0-9]*([\\.|\\-|_][a-zA-Z0-9]+)*";
        // show(wrongNames(), nameMask);
        // show(rightNames(), nameMask);

        String domainMask = "[a-zA-Z]+[a-zA-Z0-9]*([\\.|\\-|_][a-zA-Z0-9]+)+";
        // show(wrongDomains(), domainMask);
        // show(rightDomains(), domainMask);

        String at = "@";
        String emailMask = nameMask + at + domainMask;
        show(rightNames(), rightDomains(), emailMask);
        show(rightNames(), wrongDomains(), emailMask);
        show(wrongNames(), wrongDomains(), emailMask);
    }
    public static void main(String[] args) {
        new Expressao().start();
    }
}

Se alguém encontrar algum caso que não esteja sendo previsto avise para que possamos incrementar a robustez.

Grato, T+

Boa Tarde,

Pode me comentar o seu código ?

Não estou compreendendo as partes, queria desmembrar o código para fazer uma outra class teste.

Obrigado

Criado 14 de julho de 2006

Ultima resposta 22 de mai. de 2015

Respostas 12

Participantes 12

12 Respostas

Topicos relacionados