Come devo convalidare un indirizzo e-mail?


320

Qual è una buona tecnica per convalidare un indirizzo e-mail (ad es. Da un campo di input dell'utente) in Android? org.apache.commons.validator.routines.EmailValidator non sembra essere disponibile. Ci sono altre librerie che fanno questo che sono già incluse in Android o dovrei usare RegExp?


per favore fai riferimento a questo, che ti possa aiutare: stackoverflow.com/questions/12947620/…
Hiren Patel,

1
@ user2757064 bene questa domanda dovrebbe aiutare l'altra domanda che hai collegato. Questa domanda è stata posta 3 anni dopo. :)
Sufian,

Risposte:


48

Non usare un reg-ex.

Apparentemente il seguente è un reg-ex che convalida correttamente la maggior parte degli indirizzi e-mail conformi a RFC 2822 , (e fallirà comunque su cose come "user@gmail.com.nospam", come org.apache.commons.validator. routines.EmailValidator)

(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])

Forse il modo più semplice per convalidare un'e-mail per inviare semplicemente un'e-mail di conferma all'indirizzo fornito e rimbalza quindi non è valido.

Se vuoi eseguire alcuni controlli di base, puoi semplicemente verificare che sia nel modulo *@*

Se si dispone di una convalida specifica per la logica aziendale, è possibile eseguire tale operazione utilizzando un regex, ad esempio deve essere un account gmail.com o qualcosa del genere.


5
So che questa risposta ha circa due anni, ma quando provo questo regex usando regexr.com, lo convalido user@gmail.com.nospame anche più a lungo come .museum. Mi sto perdendo qualcosa? Non voglio bloccare nessuno dei miei utenti non riuscendo a convalidare il loro indirizzo e-mail valido, ma questo sembra funzionare per qualsiasi cosa mi venga in mente.
Bob Vork,

@Bob convalida l'indirizzo e-mail sul server .. controlla l'app foursquare che fa lo stesso
Harsha MV,

107
Sono un po 'confuso perché inizi questa risposta con "Non usare un reg-ex" e poi procedi a fornire un reg-ex.
howettl

7
Per favore continua a leggere. Di seguito è riportata una soluzione migliore che non utilizza regex.
Loeschg,

1
@Glen. Questo sarebbe vero per il modello di Android . EMAIL_ADDRESS ? developer.android.com/reference/android/util/…
zulkarnain shah

1036

Un'altra opzione è i Pattern integrati che iniziano con API Level 8:

public final static boolean isValidEmail(CharSequence target) {
  if (TextUtils.isEmpty(target)) {
    return false;
  } else {
    return android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
  }
}

Fonte visualizzabile di modelli

O

Una soluzione di linea di @AdamvandenHoven:

public final static boolean isValidEmail(CharSequence target) {
  return !TextUtils.isEmpty(target) && android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}

30
+1, ma preferisco sostituirlo (target == null)con TextUtils.isEmpty(target):)
Houcine,

36
Risposte come queste sono il motivo per cui non mi piacciono le risposte accettate che vengono mostrate in cima, invece delle risposte con la maggior parte dei voti.
Jeshurun,

11
Non avrebbe anche più senso (leggibilità saggia) semplicemente combinare questo in una riga: return! TextUtils.isEmpty (target) && android.util.Patterns.EMAIL_ADDRESS.matcher (target) .matches ();
Adam van den Hoven,

1
@Houcine, true ma il metodo sopra restituisce valori booleani, quindi non abbiamo tali informazioni quando sono false. Ad ogni modo, si può brindare o aggiornare l'interfaccia utente dall'interno della funzione (deve essere eseguita nel thread dell'interfaccia utente). Per quelli come me, che stanno convalidando un'e-mail ottenuta a livello di codice e senza alcuna interazione da parte dell'utente, possiamo semplicemente attenerci a '== null' e forse salvare un paio di cicli di clock nella maggior parte dei casi.
AJ,

2
Stai attento. Questo matcher accetta email@111.222.333.44444come email valida
Joaquin Iurchuk,

101

Il modello successivo viene utilizzato nella posta K-9:

public static final Pattern EMAIL_ADDRESS_PATTERN = Pattern.compile(
          "[a-zA-Z0-9\\+\\.\\_\\%\\-\\+]{1,256}" +
          "\\@" +
          "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,64}" +
          "(" +
          "\\." +
          "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,25}" +
          ")+"
      );

Puoi usare la funzione

private boolean checkEmail(String email) {
        return EMAIL_ADDRESS_PATTERN.matcher(email).matches();
}

74
Perché non usare android.util.Patterns.EMAIL_ADDRESS?
Sergey Metlov,

9
causa esiste solo dal livello API 8
Andrei Buneyeu,

questo mi ha aiutato molto grazie e +1 per la semplice risposta .. :)
Deepthi

Cordiali saluti: all'interno delle classi di personaggi i metacaratteri sono molto meno e il trattino sfugge automaticamente quando posto a un bordo, puoi semplificare la prima classe a [a-zA-Z0-9+._%-]e le altre a[a-zA-Z0-9-]
Robin

Ciò solo ritornare vero se la sintassi e-mail è la stessa e-mail fa, ho cercato di rimuovere ida @gmail.comesso tornerà vero. Lo stesso in `@yaho.com.
RoCk RoCk

70

Dall'API 8 (Android 2.2) esiste un modello: android.util.Patterns.EMAIL_ADDRESS http://developer.android.com/reference/android/util/Patterns.html

Quindi puoi usarlo per convalidare il tuo EmailString:

private boolean isValidEmail(String email) {
    Pattern pattern = Patterns.EMAIL_ADDRESS;
    return pattern.matcher(email).matches();
}

ritorna vero se l'e-mail è valida

UPD: questo codice sorgente del modello è:

public static final Pattern EMAIL_ADDRESS
    = Pattern.compile(
        "[a-zA-Z0-9\\+\\.\\_\\%\\-\\+]{1,256}" +
        "\\@" +
        "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,64}" +
        "(" +
            "\\." +
            "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,25}" +
        ")+"
    );

consultare: http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.2_r1.1/android/util/Patterns.java

Quindi puoi costruirlo tu stesso per la compatibilità con API <8.


45

Ora abbiamo un semplice abbinatore di modelli di email

 private static boolean isValidEmail(String email) {
        return !TextUtils.isEmpty(email) && android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
    }

19

Utilizza un semplice codice di una riga per la convalida dell'email

public static boolean isValidEmail(CharSequence target) {
    return !TextUtils.isEmpty(target) && android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}

usa come ...

if (!isValidEmail(yourEdittext.getText().toString()) {
    Toast.makeText(context, "your email is not valid", 2000).show();
}

15

Ecco i suggerimenti di Android Studio:

public static boolean isEmailValid(String email) {
    return !(email == null || TextUtils.isEmpty(email)) && android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
}

1
null check email == nullè redandunt mentre TextUtils lo controlla all'interno
Volodymyr,

@VolodymyrKhodonovych hai ragione, ma il controllo nullo viene eseguito in uno stato OR, non farlo potrebbe portare a un NPE quando si passa la posta elettronica al metodo matcher ().
Matteo

11

È possibile utilizzare l'espressione regolare per farlo. Qualcosa di simile al seguente.

Pattern pattern = Pattern.compile(".+@.+\\.[a-z]+");

String email = "xyz@xyzdomain.com";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

Nota: controlla l'espressione regolare indicata sopra, non usarla così com'è.


3
Ciò viene a mancare al seguente indirizzo e-mail valido: "Example Guy" <guy@example.com>. Mentre tecnicamente puoi convalidare la posta elettronica con un regex , è un po 'assurdo farlo.
Cory Petosky,

1
Quello non è solo un indirizzo email però.
Brill Pappin,

11

usa android: inputType = "textEmailAddress" come di seguito:

       <EditText
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="email"
        android:inputType="textEmailAddress"
        android:id="@+id/email"
        />

e:

       boolean isEmailValid(CharSequence email) {
        return android.util.Patterns.EMAIL_ADDRESS.matcher(email)
                .matches();
      }

11

Puoi scrivere un'estensione di Kotlin in questo modo:

fun String.isValidEmail() =
        this.isNotEmpty() && android.util.Patterns.EMAIL_ADDRESS.matcher(this).matches()

E poi chiamalo così:

email.isValidEmail()

chi è "Patterns"?
Jemshit Iskenderov,

android.util.Patterns
Danilo Lemes il

9

C'è una Patternsclasse nel pacchetto android.utilche è utile qui. Di seguito è riportato il metodo che uso sempre per convalidare la posta elettronica e molti altri elementi

private boolean isEmailValid(String email) {
    return !TextUtils.isEmpty(email) && Patterns.EMAIL_ADDRESS.matcher(email).matches();
}

5

Chiama questo metodo dove desideri convalidare l'ID e-mail.

public static boolean isValid(String email)
{
   String expression = "^[\\w\\.-]+@([\\w\\-]+\\.)+[A-Z]{2,4}$";
   CharSequence inputStr = email;
   Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE);
   Matcher matcher = pattern.matcher(inputStr);
   if (matcher.matches()) 
   {
      return true;
   }
   else{
   return false;
   }
}

5

Per una convalida via e-mail Android fornisce alcuni InBuilt Pattern . Ma supporta solo API livello 8 e superiore .

Ecco il codice per utilizzare quel modello per verificare la convalida dell'email.

  private boolean Email_Validate(String email) 
  {
    return android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
  }

Assicurarsi che dopo aver eseguito questo metodo sia necessario verificare che se questo metodo restituisce true, si consenta di salvare la posta elettronica e se questo metodo restituisce false, visualizzare il messaggio che la posta elettronica è "Non valida".

Spero che tu abbia la tua risposta, grazie.


4

Posso consigliare vivamente di non provare a "convalidare" gli indirizzi e-mail, ti impegnerai in un sacco di lavoro senza una buona ragione.

Assicurati solo che ciò che viene inserito non rompa il tuo codice, ad esempio senza spazi o caratteri illegali che potrebbero causare un'eccezione.

Qualsiasi altra cosa ti causerà molto lavoro per un ritorno minimo ...


3
Quando si lavora con abbonamenti e pagamenti, questo non è un consiglio utile. Se qualcuno dimentica la password, dobbiamo avere un modo per reimpostare in modo sicuro la password per consentire loro di continuare a utilizzare il servizio per cui hanno pagato. Quindi a volte è meglio assicurarci che stiano inserendo un indirizzo e-mail valido per il loro bene.
Dean Wild,

1
Giusto per essere chiari su ciò che ho detto - se qualcuno ha intenzione di inserire un indirizzo falso / sbagliato - nessuna quantità di convalida li fermerà .. Controllare errori sciocchi come spazi e nessun '@' ecc. Va bene - controllare qualcos'altro è bene in "rendimenti decrescenti" ...

3
L'unico modo per identificare un'e-mail falsa è tramite l'invio di un'e-mail a
quell'ID

John, molti utenti non intendono inserire un indirizzo falso / sbagliato, ma possono inserirlo in modo errato per errore. Quindi eseguire un semplice controllo può essere molto utile e, come mostrato nella risposta di Mindriot, non richiede molto lavoro. Dalla mia esperienza, la maggior parte delle persone inserisce correttamente i loro indirizzi e-mail e le poche e-mail non valide spesso dipendono da errori di battitura.
divieto di geoingegneria il

Se è importante che l'e-mail dell'utente funzioni, invia un'email di conferma. Tutto il resto è una sciocchezza.
L'incredibile gennaio

4

Convalida il formato del tuo indirizzo email. Ex-virag@gmail.com

public boolean emailValidator(String email) 
{
    Pattern pattern;
    Matcher matcher;
    final String EMAIL_PATTERN = "^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$";
    pattern = Pattern.compile(EMAIL_PATTERN);
    matcher = pattern.matcher(email);
    return matcher.matches();
}

3
    public boolean isValidEmail(String email)
{
    boolean isValidEmail = false;

    String emailExpression = "^[\\w\\.-]+@([\\w\\-]+\\.)+[A-Z]{2,4}$";
    CharSequence inputStr = email;

    Pattern pattern = Pattern.compile(emailExpression, Pattern.CASE_INSENSITIVE);
    Matcher matcher = pattern.matcher(inputStr);
    if (matcher.matches())
    {
        isValidEmail = true;
    }
    return isValidEmail;
}

2

Se si utilizza API 8 o versione successiva, è possibile utilizzare la Patternsclasse prontamente disponibile per convalidare la posta elettronica. Codice di esempio:

public final static boolean isValidEmail(CharSequence target) {
    if (target == null) 
        return false;

    return android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}

Per caso se stai persino supportando un livello API inferiore a 8, puoi semplicemente copiare il Patterns.javafile nel tuo progetto e fare riferimento a esso. È possibile ottenere il codice sorgente per Patterns.javada questo link


2

Qui è android.util.Patterns.EMAIL_ADDRESS

[A-zA-Z0-9 + ._ \% - +] {1256} \ @ [a-zA-Z0-9] [a-zA-Z0-9 -]. {0,64} ([a- zA-Z0-9] [a-zA-Z0-9 -] {0,25}) +

String lo abbinerà se

Start by 1->256 character in (a-z, A-Z, 0-9, +, ., _, %, - , +)  
then 1 '@' character  
then 1 character in (a-z, A-Z, 0-9)  
then 0->64 character in (a-z, A-Z, 0-9, -)  
then **ONE OR MORE** 
         1 '.' character   
    then 1 character in (a-z, A-Z, 0-9)   
    then 0->25 character in (a-z, A-Z, 0-9, -)

Esempio di e-mail di corrispondenza speciale

a@b.c
a+@b-.c
a@b.c.d.e.f.g.h

Puoi modificare questo modello per il tuo caso, quindi confermare

fun isValidEmail(email: String): Boolean {
    return Patterns.EMAIL_ADDRESS.matcher(email).matches()
}

1

Prova questo semplice metodo che non può accettare l'indirizzo e-mail che inizia con le cifre:

boolean checkEmailCorrect(String Email) {
    if(signupEmail.length() == 0) {
        return false;
    }

    String pttn = "^\\D.+@.+\\.[a-z]+";
    Pattern p = Pattern.compile(pttn);
    Matcher m = p.matcher(Email);

    if(m.matches()) {
        return true;
    }

    return false;
}

1

Prova questo codice .. Funziona davvero ..

            if (!email
                    .matches("^[\\w-_\\.+]*[\\w-_\\.]\\@([\\w]+\\.)+[\\w]+[\\w]$"))
            {
                Toast.makeText(getApplicationContext(), "Email is invalid",
                        Toast.LENGTH_LONG).show();
                return;
            }

1

Il seguito è stato usato da me. Tuttavia contiene caratteri extra rispetto alle normali e-mail, ma questo era un requisito per me.

public boolean isValidEmail(String inputString) {
    String  s ="^((?!.*?\.\.)[A-Za-z0-9\.\!\#\$\%\&\'*\+\-\/\=\?\^_`\{\|\}\~]+@[A-Za-z0-9]+[A-Za-z0-9\-\.]+\.[A-Za-z0-9\-\.]+[A-Za-z0-9]+)$";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(inputString);
    return matcher.matches();
}

Risposta a questa domanda: - Requisito per convalidare un indirizzo e-mail con determinati punti

Spiegazione-

  1. (?!. *? ..) "Negative Lookhead" per negare 2 punti consecutivi.
  2. [A-Za-z0-9.! # \ $ \% \ & \ '* + - / \ = \? \ ^ _ `{\ |} \ ~] + Almeno uno definito. ("\" viene utilizzato per la escape).
  3. @ Potrebbe esserci un "@".
  4. [A-Za-z0-9] + quindi almeno un personaggio definito.
  5. [A-Za-z0-9 -.] * Zero o qualsiasi ripetizione del carattere definita.
  6. [A-Za-z0-9] + almeno un carattere dopo punto.

1

La chiave qui è che vuoi validare completamente l'indirizzo email. Non vuoi solo verificarne la correttezza sintattica, ma vuoi verificare se l'indirizzo e-mail è reale.

Due ovvi motivi: gli utenti reali spesso digitano male i loro indirizzi e -mail e alcuni utenti possono inserire indirizzi e-mail falsi. Pertanto, si desidera eseguire un controllo sintattico e un controllo di esistenza.

Il modo migliore per farlo che ho trovato su Android è utilizzare l' API di convalida Cloudmersive gratuita per questo.

Il codice è simile al seguente:

ApiClient defaultClient = Configuration.getDefaultApiClient();

// Configure API key authorization: Apikey
ApiKeyAuth Apikey = (ApiKeyAuth) defaultClient.getAuthentication("Apikey");
Apikey.setApiKey("YOUR API KEY");

EmailApi apiInstance = new EmailApi();
String email = "email_example"; // String | Email address to validate, e.g. \"support@cloudmersive.com\". The input is a string so be sure to enclose it in double-quotes.
try {
    FullEmailValidationResponse result = apiInstance.emailFullValidation(email);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling EmailApi#emailFullValidation");
    e.printStackTrace();
}

Lo sto usando in tutte le mie app ed è fantastico perché posso convalidare gli indirizzi e-mail nella UX al punto di entrata.


1

La soluzione Kotlin più semplice che utilizza le funzioni di estensione:

fun String.isEmailValid() =
            Pattern.compile(
                    "[a-zA-Z0-9\\+\\.\\_\\%\\-\\+]{1,256}" +
                            "\\@" +
                            "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,64}" +
                            "(" +
                            "\\." +
                            "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,25}" +
                            ")+"
            ).matcher(this).matches()

e quindi puoi convalidare in questo modo:

"testemail6589@gmail.com".isEmailValid()

0

Nota che la maggior parte delle espressioni regolari non sono valide per nomi di dominio internazionali (IDN) e nuovi domini di primo livello come .mobi o .info (se controlli i codici paese o .org, .com, .gov e così via).

Un controllo valido dovrebbe separare la parte locale (prima del segno di at) e la parte del dominio. Dovresti anche considerare la lunghezza massima della parte locale e del dominio (in somma 255 caratteri incluso il segno at).

L'approccio migliore è trasformare l'indirizzo in un formato compatibile IDN (se richiesto), convalidare la parte locale (RFC), verificare la lunghezza dell'indirizzo e verificare la disponibilità del dominio (ricerca DNS MX) o semplicemente inviare un'e-mail .



0

Ho usato il codice seguente: funziona bene, spero che questo ti possa aiutare.

if (validMail(yourEmailString)){
   //do your stuf
 }else{
 //email is not valid.
}

e utilizza il metodo follwing. Questo restituisce true se l'e-mail è valida.

    private boolean validMail(String yourEmailString) {
    Pattern emailPattern = Pattern.compile(".+@.+\\.[a-z]+");
    Matcher emailMatcher = emailPattern.matcher(emailstring);
    return emailMatcher.matches();
}

0

l'email è la tua email.

public boolean validateEmail(String email) {

    Pattern pattern;
    Matcher matcher;
    String EMAIL_PATTERN = "^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$";
    pattern = Pattern.compile(EMAIL_PATTERN);
    matcher = pattern.matcher(email);
    return matcher.matches();

    }

0

Per gli amanti dei regex, il modello di email migliore (ad es. Coerente con RFC 822) che abbia mai trovato da ora è il seguente (prima che PHP fornisse i filtri). Immagino sia facile tradurlo in Java - per chi gioca con API <8:

private static function email_regex_pattern() {
// Source:  http://www.iamcal.com/publish/articles/php/parsing_email
$qtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]';
$dtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]';
$atom = '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c'.
    '\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+';
$quoted_pair = '\\x5c[\\x00-\\x7f]';
$domain_literal = "\\x5b($dtext|$quoted_pair)*\\x5d";
$quoted_string = "\\x22($qtext|$quoted_pair)*\\x22";
$domain_ref = $atom;
$sub_domain = "($domain_ref|$domain_literal)";
$word = "($atom|$quoted_string)";
$domain = "$sub_domain(\\x2e$sub_domain)*";
$local_part = "$word(\\x2e$word)*";
$pattern = "!^$local_part\\x40$domain$!";
return $pattern ;
}

0

Puoi eseguire qualsiasi tipo di convalida in Android molto facilmente dal file oval.jar. OVal è un framework pragmatico ed estensibile di validazione per tutti gli oggetti Java.

segui questo link: http://oval.sourceforge.net/userguide.html

Puoi scaricarlo da qui: http://oval.sourceforge.net/userguide.html#download

È possibile utilizzare la convalida impostando i tag nelle variabili

public class Something{

    @NotEmpty  //not empty validation
    @Email     //email validation
    @SerializedName("emailAddress")
    private String emailAddress;
}

   private void checkValidation() {
        Something forgotpass.setEmailAddress(LoginActivity.this.dialog_email.getText().toString());
        Validator validator = new Validator();
        //collect the constraint violations
        List<ConstraintViolation> violations = validator.validate(forgotpass);
        if(violations.size()>0){
            for (ConstraintViolation cv : violations){
                if(cv.getMessage().contains("emailAddress")){
                    dialog_email.setError(ValidationMessage.formattedError(cv.getMessage(), forgotpass));
                }
            }
        }
}

0

Puoi anche usare

InternetAddress emailAddr = new InternetAddress(email);
emailAddr.validate();

Se l'e-mail non è valida, verrà generata una AddressException .

Sfortunatamente Android non supporta jndi-dns , ma solo per darti un'idea di una più potente convalida e-mail, puoi usarla per convalidare il dominio e-mail. Forse un guru di Android potrebbe aiutare e mostrare se ci sono alternative simili ... Un'implementazione di esempio con Java "normale" è disponibile qui .

MODIFICARE

Mi sono appena reso conto che javax.mail non supporta neanche ... Ma questo post mostra una soluzione alternativa .

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.