Expressão regular de validação de email

carneiro · Julho 14, 2006, 9:55am

Pessoal,

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

Obrigado,

cassio · Julho 14, 2006, 10:33am

String regex = "[A-Za-z0-9\\._-]+@[A-Za-z]+\\.[A-Za-z]+";
String email = "blablabla@blablabla.blablabla";
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 · Setembro 21, 2006, 10:29am

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

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 · Setembro 21, 2006, 12:19pm

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

Grato!

apo · Setembro 21, 2006, 6:08pm

[quote=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
}[/quote]

Isso é javascript

iktuz · Maio 7, 2007, 7:08pm

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 · Junho 16, 2007, 2:59am

[quote=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+[/quote]
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 · Dezembro 26, 2008, 10:36am

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 · Setembro 26, 2009, 3:18pm

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 · Outubro 14, 2009, 5:38pm

[quote=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!
[/quote]

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 · Dezembro 2, 2009, 4:52pm

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 &quot;,&quot; ou &quot;;&quot;
        if(email.split(&quot;;&quot;).length &gt; 1)
            listaEmails = email.split(&quot;;&quot;);
        else  if(email.split(&quot;,&quot;).length &gt; 1)
            listaEmails = email.split(&quot;,&quot;);

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

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

        }

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

RodReis · Agosto 8, 2013, 2:56pm

[quote=cassio]String regex = "[A-Za-z0-9\\._-]+@[A-Za-z]+\\.[A-Za-z]+"; String email = "blablabla@blablabla.blablabla"; 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!
[/quote]

Fiz uma modificação para funcionar redondo:

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

Leandro_Hung · Maio 22, 2015, 9:31pm

[quote=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+[/quote]

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

Expressão regular de validação de email

Cursos de Mobile

Cursos de Programação

Cursos de Front-end

Cursos de DevOps

Cursos de Design & UX

Cursos de Business

Cursos de Data & BI