Comment valider une adresse e-mail en PHP

J'ai cette fonction pour valider une adresse email:

function validateEMAIL($EMAIL) {
    $v = "/[a-zA-Z0-9_-.+]+@[a-zA-Z0-9-]+.[a-zA-Z]+/";

    return (bool)preg_match($v, $EMAIL);
}

Est-ce correct de vérifier si l'adresse e-mail est valide ou non?

La façon la plus simple et la plus sûre de vérifier si une adresse e-mail est bien formée est d'utiliser la filter_var()fonction:

if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
    // invalid emailaddress
}

De plus, vous pouvez vérifier si le domaine définit un MXenregistrement:

if (!checkdnsrr($domain, 'MX')) {
    // domain is not valid
}

Mais cela ne garantit toujours pas que le courrier existe. La seule façon de le savoir est d'envoyer un e-mail de confirmation.

Maintenant que vous avez votre réponse facile, n'hésitez pas à lire sur la validation des adresses e-mail si vous souhaitez apprendre ou utiliser simplement la réponse rapide et continuer. Pas d'émotions fortes.

Tenter de valider une adresse e-mail à l'aide d'une expression régulière est une tâche «impossible». J'irais jusqu'à dire que ce regex que vous avez fait est inutile. Il y a trois RFC concernant les adresses e-mail et l'écriture d'une expression rationnelle pour attraper les adresses e-mail erronées et en même temps, ne pas avoir de faux positifs, c'est quelque chose qu'aucun mortel ne peut faire. Consultez cette liste pour les tests (échoués et réussis) de l'expression rationnelle utilisée par la filter_var()fonction PHP .

Même les fonctions PHP intégrées, les clients de messagerie ou les serveurs ne fonctionnent pas correctement. Dans la plupart des cas, filter_varc'est toujours la meilleure option.

Si vous voulez savoir quel modèle d'expression régulière PHP (actuellement) utilise pour valider les adresses e-mail, consultez la source PHP .

Si vous voulez en savoir plus sur les adresses e-mail, je vous suggère de commencer à lire les spécifications, mais je dois vous avertir que ce n'est pas une lecture facile par tous les bouts:

• rfc5322
• rfc5321
• rfc3696
• rfc6531 (autorise les caractères unicode, bien que de nombreux clients / serveurs ne l'acceptent pas)

Notez que cela filter_var()n'est déjà indiqué que disponible à partir de PHP 5.2. Si vous voulez qu'il fonctionne avec des versions antérieures de PHP, vous pouvez utiliser l'expression régulière utilisée en PHP:

<?php

$pattern = '/^(?!(?:(?:\\x22?\\x5C[\\x00-\\x7E]\\x22?)|(?:\\x22?[^\\x5C\\x22]\\x22?)){255,})(?!(?:(?:\\x22?\\x5C[\\x00-\\x7E]\\x22?)|(?:\\x22?[^\\x5C\\x22]\\x22?)){65,}@)(?:(?:[\\x21\\x23-\\x27\\x2A\\x2B\\x2D\\x2F-\\x39\\x3D\\x3F\\x5E-\\x7E]+)|(?:\\x22(?:[\\x01-\\x08\\x0B\\x0C\\x0E-\\x1F\\x21\\x23-\\x5B\\x5D-\\x7F]|(?:\\x5C[\\x00-\\x7F]))*\\x22))(?:\\.(?:(?:[\\x21\\x23-\\x27\\x2A\\x2B\\x2D\\x2F-\\x39\\x3D\\x3F\\x5E-\\x7E]+)|(?:\\x22(?:[\\x01-\\x08\\x0B\\x0C\\x0E-\\x1F\\x21\\x23-\\x5B\\x5D-\\x7F]|(?:\\x5C[\\x00-\\x7F]))*\\x22)))*@(?:(?:(?!.*[^.]{64,})(?:(?:(?:xn--)?[a-z0-9]+(?:-+[a-z0-9]+)*\\.){1,126}){1,}(?:(?:[a-z][a-z0-9]*)|(?:(?:xn--)[a-z0-9]+))(?:-+[a-z0-9]+)*)|(?:\\[(?:(?:IPv6:(?:(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){7})|(?:(?!(?:.*[a-f0-9][:\\]]){7,})(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,5})?::(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,5})?)))|(?:(?:IPv6:(?:(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){5}:)|(?:(?!(?:.*[a-f0-9]:){5,})(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,3})?::(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,3}:)?)))?(?:(?:25[0-5])|(?:2[0-4][0-9])|(?:1[0-9]{2})|(?:[1-9]?[0-9]))(?:\\.(?:(?:25[0-5])|(?:2[0-4][0-9])|(?:1[0-9]{2})|(?:[1-9]?[0-9]))){3}))\\]))$/iD';

$emailaddress = '[email protected]';

if (preg_match($pattern, $emailaddress) === 1) {
    // emailaddress is valid
}

PS Une note sur le modèle d'expression régulière utilisé ci-dessus (à partir de la source PHP). Il semble qu'il y ait des droits d'auteur sur Michael Rushton . Comme indiqué: "N'hésitez pas à utiliser et à redistribuer ce code. Mais veuillez conserver cette notice de copyright."

Vous pouvez utiliser filter_var pour cela.

<?php
   function validateEmail($email) {
      return filter_var($email, FILTER_VALIDATE_EMAIL);
   }
?>

D'après mon expérience, les regexsolutions ont trop de faux positifs et les filter_var()solutions ont de faux négatifs (en particulier avec tous les nouveaux TLD ).

Au lieu de cela, il est préférable de s'assurer que l'adresse contient toutes les parties requises d'une adresse e-mail (utilisateur, symbole "@" et domaine), puis vérifiez que le domaine lui-même existe.

Il n'y a aucun moyen de déterminer (côté serveur) si un utilisateur de messagerie existe pour un domaine externe.

Il s'agit d'une méthode que j'ai créée dans une classe Utility:

public static function validateEmail($email)
{
    // SET INITIAL RETURN VARIABLES

        $emailIsValid = FALSE;

    // MAKE SURE AN EMPTY STRING WASN'T PASSED

        if (!empty($email))
        {
            // GET EMAIL PARTS

                $domain = ltrim(stristr($email, '@'), '@') . '.';
                $user   = stristr($email, '@', TRUE);

            // VALIDATE EMAIL ADDRESS

                if
                (
                    !empty($user) &&
                    !empty($domain) &&
                    checkdnsrr($domain)
                )
                {$emailIsValid = TRUE;}
        }

    // RETURN RESULT

        return $emailIsValid;
}

Je pense que vous feriez mieux d'utiliser les filtres intégrés de PHP - dans ce cas particulier:

Il peut retourner un vrai ou un faux lorsqu'il est fourni avec le FILTER_VALIDATE_EMAILparamètre.

Cela permettra non seulement de valider votre e-mail, mais aussi de le nettoyer pour les caractères inattendus:

$email  = $_POST['email'];
$emailB = filter_var($email, FILTER_SANITIZE_EMAIL);

if (filter_var($emailB, FILTER_VALIDATE_EMAIL) === false ||
    $emailB != $email
) {
    echo "This email adress isn't valid!";
    exit(0);
}

A répondu à cette question dans la «question principale» sur la vérification des e-mails https://stackoverflow.com/a/41129750/1848217

Pour moi, la bonne façon de vérifier les e-mails est:

1. Vérifiez que le symbole @ existe, et avant et après il y a des symboles non @: /^[^@]+@[^@]+$/
2. Essayez d'envoyer un e-mail à cette adresse avec un "code d'activation".
3. Lorsque l'utilisateur "activera" son adresse e-mail, nous verrons que tout va bien.

Bien sûr, vous pouvez afficher un avertissement ou une info-bulle en front-end lorsque l'utilisateur a tapé un e-mail "étrange" pour l'aider à éviter les erreurs courantes, comme aucun point dans la partie du domaine ou des espaces dans le nom sans citer, etc. Mais vous devez accepter l'adresse "hello @ world" si l'utilisateur le veut vraiment.

En outre, vous devez vous rappeler que la norme d'adresse e-mail a été et peut évoluer, vous ne pouvez donc pas simplement taper une expression rationnelle "standard valide" une fois pour toutes. Et vous devez vous rappeler que certains serveurs Internet concrets peuvent faire échouer certains détails de la norme commune et, en fait, fonctionner avec leur propre "norme modifiée".

Donc, il suffit de cocher @, d'indiquer l'utilisateur sur le frontend et d'envoyer des e-mails de vérification à une adresse donnée.

Si vous souhaitez vérifier si le domaine fourni à partir de l'adresse e-mail est valide, utilisez quelque chose comme:

/*
* Check for valid MX record for given email domain
*/
if(!function_exists('check_email_domain')){
    function check_email_domain($email) {
        //Get host name from email and check if it is valid
        $email_host = explode("@", $email);     
        //Add a dot to the end of the host name to make a fully qualified domain name and get last array element because an escaped @ is allowed in the local part (RFC 5322)
        $host = end($email_host) . "."; 
        //Convert to ascii (http://us.php.net/manual/en/function.idn-to-ascii.php)
        return checkdnsrr(idn_to_ascii($host), "MX"); //(bool)       
    }
}

C'est un moyen pratique de filtrer un grand nombre d'adresses e-mail non valides, ainsi qu'une validation standard des e-mails, car un format d'e-mail valide ne signifie pas un e-mail valide .

Notez que la fonction idn_to_ascii()(ou sa fonction sœur idn_to_utf8()) peut ne pas être disponible dans votre installation PHP, elle nécessite les extensions PECL intl> = 1.0.2 et PECL idn> = 0.1.

Gardez également à l'esprit que IPv4 ou IPv6 en tant que partie de domaine dans le courrier électronique (par exemple user@[IPv6:2001:db8::1]) ne peut pas être validé, seuls les hôtes nommés le peuvent.

Voir plus ici .

Après avoir lu les réponses ici, voici ce que je me suis retrouvé avec:

public static function isValidEmail(string $email) : bool
{
    if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        return false;
    }

    //Get host name from email and check if it is valid
    $email_host = array_slice(explode("@", $email), -1)[0];

    // Check if valid IP (v4 or v6). If it is we can't do a DNS lookup
    if (!filter_var($email_host,FILTER_VALIDATE_IP, [
        'flags' => FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE,
    ])) {
        //Add a dot to the end of the host name to make a fully qualified domain name
        // and get last array element because an escaped @ is allowed in the local part (RFC 5322)
        // Then convert to ascii (http://us.php.net/manual/en/function.idn-to-ascii.php)
        $email_host = idn_to_ascii($email_host.'.');

        //Check for MX pointers in DNS (if there are no MX pointers the domain cannot receive emails)
        if (!checkdnsrr($email_host, "MX")) {
            return false;
        }
    }

    return true;
}

Si vous êtes à la recherche d'un regex qui permet de divers points, tirets et underscores, il suit que: [a-zA-z0-9.-]+\@[a-zA-z0-9.-]+.[a-zA-Z]+. Cela permettra de tom_anderson.1-neo@my-mail_matrix.comvalider un e-mail d'aspect assez stupide .

/(?![[:alnum:]]|@|-|_|\.)./

De nos jours, si vous utilisez un formulaire HTML5 avec, type=emailvous êtes déjà à 80% en sécurité car les moteurs de navigateur ont leur propre validateur. Pour le compléter, ajoutez cette expression régulière à votre preg_match_all()et annulez-la:

if (!preg_match_all("/(?![[:alnum:]]|@|-|_|\.)./",$email)) { .. }

Trouvez l'expression régulière utilisée par les formulaires HTML5 pour la validation
https://regex101.com/r/mPEKmy/1