Verifique la dirección de correo electrónico y compruebe si el correo electrónico es real utilizando PHP


Verificar la dirección de correo electrónico es una tarea difícil pero obligatoria en el mundo web. Un correo electrónico válido puede ayudar a que su comercialización sea rentable. Pero un correo electrónico no válido aumenta su costo de marcado y los efectos en la reputación del cliente de correo electrónico. Del mismo modo, la validación de correo electrónico es la funcionalidad común y útil en la aplicación web. Antes de trabajar con la dirección de correo electrónico, se debe verificar y verificar si el correo electrónico es válido o no.
La validación del correo electrónico en PHP se puede hacer fácilmente usando la función filter_var () con el filtro FILTER_VALIDATE_EMAIL. Verificará si el formato de la dirección de correo electrónico dada es válido. Pero solo este filtro no es suficiente para verificar si existe una dirección de correo electrónico. En este tutorial, le mostraremos cómo verificar si una dirección de correo electrónico es real y existe mediante PHP.
En la secuencia de comandos de verificación de correo electrónico de PHP , validaremos una dirección de correo electrónico mediante la verificación del registro DNS DNS y el dominio. Este script es muy útil para verificar la dirección de correo electrónico del usuario antes de enviar un correo electrónico o insertarlo en la base de datos. Puede diferenciar direcciones de correo electrónico reales e inválidas, y aceptar solo la dirección de correo electrónico válida del usuario.

Biblioteca de verificación de correo electrónico de PHP

La clase VerifyEmail se usa para verificar si una dirección de correo electrónico es válida y real usando el protocolo SMTP en PHP. Debe usar una función de la clase VerifyEmail para verificar la dirección de correo electrónico en PHP.
comprobar()
  • Valide el formato de la dirección de correo electrónico.
  • Obtener registros MX del dominio de la dirección de correo electrónico.
  • Conectarse al servidor SMTP por los registros MX.
  • Basado en el código de respuesta:
    • Compruebe si la dirección de correo electrónico del destinatario es válida.
    • Compruebe si el usuario del dominio de correo electrónico existe.
    • Compruebe la entrega del mensaje.
<? php  / **  
 * Clase para validar la dirección de correo electrónico  
 *  
 * @author CodexWorld.com <contact@codexworld.com>  
 * @copyright Copyright (c) 2018, CodexWorld.com 
 * @url https: //www.codexworld. com 
 * /  class  VerifyEmail  

    protected  $ stream  false 

    / **  
     * Número de puerto SMTP  
     * @var int  
     * /  
    protected  $ port  25 

    / **  
     * Dirección de correo electrónico para solicitud  
     * @var string  
     * /  
    protected  $ from  'root @ localhost' 

    / **  
     * El tiempo de espera de la conexión, en segundos. 
     * @var int  
     * /  
    protected  $ max_connection_timeout  30 

    / **  
     * Valor de tiempo de espera en secuencia, en segundos. 
     * @var int  
     * /  
    protected  $ stream_timeout  5 

    / **  
     * Tiempo de espera de espera en la transmisión, en segundos. 
     * * 0: no esperar  
     * @var int  
     * /  
    protected  $ stream_timeout_wait  0 

    / **  
     * Si lanzar excepciones por errores. 
     * @type boolean  
     * @access protected 
     * /  
    Protegidas  $ excepciones  false 

    / **  
     * El número de errores encontrados. 
     * @type integer  
     * @access protected  
     * /  
    protected  $ error_count  0 

    / **  
     * modo de salida de depuración de clase. 
     * @type boolean  
     * /  
    public  $ Debug  false 

    / **  
     * Cómo manejar la salida de depuración. 
     * Opciones:  
     * * `echo` Salida de texto plano tal como es, apropiada para CLI  
     * *` `html` Salida escapada, saltos de línea convertidos a` <br> `, apropiada para la salida del navegador 
     * * `log` Salida a registro de errores como se configura en php.ini  
     * @type string  
     * /  
    public  $ Debugoutput  'echo' 

    / **  
     * Fin de línea estándar SMTP RFC. 
     * /  
    const  CRLF  "\ r \ n" 

    / **  
     * Contiene el mensaje de error más reciente. 
     * @tipo cadena  
     * /  
    public  $ ErrorInfo  '' 

    / **  
     * Constructor. 
     * @param boolean $ excepciones ¿Deberíamos lanzar excepciones externas? 
     * /  
    public function  __construct ($ excepciones  falso ) {  
        $ esto -> excepciones  = (booleano)  $ excepciones 
    }  

    / **  
     * Establecer dirección de correo electrónico para solicitud SMTP  
     * @param string $ dirección de correo electrónico  
     * /  
    función pública  setEmailFrom ( $ email ) {  
        if (! Self :: validate ( $ email )) {  
            $ this -> set_error ( 'Invalid dirección: '  $ email ); 
            $ este -> edebug ( $ este ->ErrorInfo ); 
            if ( $ this -> exceptions ) {  
                lanza la nueva  excepción VerifyEmailException ( $ this -> ErrorInfo ); 
            }  
        }  
        $ this -> from  $ email 
    }  

    / **  
     * Establecer el tiempo de espera de conexión, en segundos. 
     * @param int $ seconds  
     * /  
    public function  setConnectionTimeout ( $ seconds ) {  
        si ( $ segundos  0 ) {  
            $ esto ->max_connection_timeout  = (int)  $ segundos 
        }  
    }  

    / **  
     * Establece el valor de tiempo de espera en la secuencia, expresado en segundos  
     * @param int $ segundos  
     * /  
    función pública  setStreamTimeout ( $ segundos ) {  
        si ( $ segundos  0 ) {  
            $ esto -> stream_timeout  = (int)  $ segundos 
        }  
    }  

    función pública  setStreamTimeoutWait ( $ segundos ) {  
        si ( $ segundos  > =  0) {  
            $ this -> stream_timeout_wait  = (int)  $ seconds 
        }  
    }  

    / **  
     * Validar dirección de correo electrónico. 
     * @param string $ email  
     * @return boolean True si es válido. 
     * /  
    public static function  validate ( $ email ) {  
        return (boolean)  filter_var ( $ email FILTER_VALIDATE_EMAIL ); 
    }  

    / **  
     * Obtener matriz de registros MX para el host. Ordenar por peso de la información. 
     * @param string $ hostname El nombre de host de Internet. 
     * @return array Array de los registros MX encontrados. 
     * /  
    public function  getMXrecords ( $ hostname ) {  
        $ mxhosts  = array (); 
        $ mxweights  = array (); 
        if ( getmxrr ( $ hostname $ mxhosts $ mxweights ) ===  FALSE ) {  
            $ this -> set_error ( 'No se encontraron registros MX o se produjo un error' ); 
            $ this -> edebug ( $ this -> ErrorInfo ); 
        } else {  
            array_multisort ($ mxweights $ mxhosts ); 
        }  
        / **  
         * Agregar un registro A como última oportunidad (por ejemplo, si no hay un registro MX). 
         * Gracias Nicht Lieb. 
         * @link http://www.faqs.org/rfcs/rfc2821.html RFC 2821 - Protocolo simple de transferencia de correo  
         * /  
        if (vacío ( $ mxhosts )) {  
            $ mxhosts [] =  $ hostname 
        }  
        devolver  $ mxhosts 
    }  

    / **  
     * Analiza la cadena de entrada a la matriz (0 => usuario, 1 => dominio)  
     * @param string $ email  
     * @param boolean $ only_domain  
     * @return string | array 
     * @access privado  
     * /  
    public static function  parse_email ( $ email $ only_domain  TRUE ) {  
        sscanf ( $ email "% [^ @] @% s" $ usuario $ dominio ); 
        volver ( $ only_domain )? $ dominio  : matriz ( $ usuario $ dominio ); 
    }  

    / **  
     * Agregar un mensaje de error al contenedor de errores. 
     * @access protected  
     * @param string $ msg  
     * @return void  
     * /  
    protected function set_error ( $ msg ) {  
        $ this -> error_count ++; 
        $ this -> ErrorInfo  $ msg 
    }  

    / **  
     * Comprobar si se produjo un error. 
     * @access public  
     * @return boolean True si se produjo un error. 
     * /  
    public function  isError () {  
        return ( $ this -> error_count  0 ); 
    }  

    / **  
     * Información de depuración de salida  
     * Solo genera salida si la salida de depuración está habilitada  
     * @ver VerifyEmail :: $ Debugoutput 
     * @ver VerifyEmail :: $ Debug  
     * @param string $ str  
     * /  
    función protegida  edebug ( $ str ) {  
        if (! $ this -> Debug ) {  
            return; 
        }  
        switch ( $ this -> Debugoutput ) {  
            case  'log' 
                // No 
                muestra , solo registra  error_log ( $ str ); 
                descanso; 
            case  'html' 
                // Limpia la salida un poco para una salida más segura y segura para HTML  
                echo  htmlentities
                        preg_replace ( '/ [\ r \ n] + /' '' $ str ),  ENT_QUOTES 'UTF-8'  
                
                . "<br> \ n" 
                descanso; 
            caso  'echo' 
            predeterminado:  
                // Normalizar saltos de línea  
                $ str  preg_replace ( '/ (\ r \ n | \ r | \ n) / ms' "\ n" $ str ); 
                echo  gmdate ( 'Ymd H: i: s' ). "\ t"  
                        "\ n \ t" recortar ( $ str 
                ). "\ n" 
        }  
    }  

    / **  
     * Validar correo electrónico 
     * @param cadena $ dirección de correo electrónico  
     * @return boolean True si también existe el correo electrónico válido  
     * /  
    comprobación de función pública  ( $ correo electrónico ) {  $ resultado  FALSO         if (! self :: validate ( $ email )) {  $ this -> set_error ( " { $ email }
        


             correo electrónico incorrecto " );  
            $ this -> edebug ( $ this -> ErrorInfo );  
            if ( $ this -> exceptions ) {  
                lanza una nueva  excepción VerifyEmailException ( $ this -> ErrorInfo );  
            }  
            return  FALSE 
        }  
        $ this -> error_count  0 // Restablecer errores  
        $ this -> stream  FALSE 

        $ mxs  $ this ->getMXrecords ( self :: parse_email ( $ email )); 
        $ timeout  ceil ( $ this -> max_connection_timeout  count ( $ mxs )); 
        foreach ( $ mxs  como  $ host ) {  
            / **  
             * suprime la salida de error del cliente de socket de corriente ...  
             * Gracias Michael. 
             * /  
            $ this -> stream  = @ stream_socket_client ( "tcp: //"  $ host  ":"  $ this -> port $ errno $ errstr $ timeout ); 
            if ( $ this -> stream  ===  FALSE ) {  
                if ( $ errno  ==  0 ) {  
                    $ this -> set_error ( "Problema al inicializar el socket" ); 
                    $ this -> edebug ( $ this -> ErrorInfo ); 
                    si ( $ esto -> excepciones ) {  
                        lanzar nuevo verifyEmailException ( $ this -> ErrorInfo ); 
                    }  
                    devuelve  FALSO 
                } else {  
                    $ this -> edebug ( $ host  ":"  $ errstr ); 
                }  
            } else else {  
                stream_set_timeout ( $ this -> stream $ this -> stream_timeout ); 
                stream_set_blocking ( $ this -> stream 1 ); 

                if ( $ this -> _streamCode ( $ this -> _streamResponse ()) ==  '220' ) {  
                    $ this -> edebug ( "Conexión exitosa  { $ host } " ); 
                    descanso; 
                } else {  
                    fclose ( $ this -> stream ); 
                    $ this -> stream  FALSE 
                }  
            }  
        }  

        if ( $ this -> stream  === FALSO ) {  
            $ this -> set_error ( " Fallo en todas las conexiones" ); 
            $ this -> edebug ( $ this -> ErrorInfo ); 
            if ( $ this -> exceptions ) {  
                lanza la nueva  excepción VerifyEmailException ( $ this -> ErrorInfo ); 
            }  
            devuelve  FALSO 
        }  

        $ this -> _streamQuery ( "HELO"  self :: parse_email ($ esto -> desde )); 
        $ this -> _streamResponse (); 
        $ this -> _streamQuery ( "MAIL FROM: < { $ this -> from } >" ); 
        $ this -> _streamResponse (); 
        $ this -> _streamQuery ( "RCPT TO: < { $ email } >" ); 
        $ code  $ this -> _streamCode ( $ this -> _streamResponse ()); 
        $ esto -> _streamResponse(); 
        $ this -> _streamQuery ( "RSET" ); 
        $ this -> _streamResponse (); 
        $ code2  $ this -> _streamCode ( $ this -> _streamResponse ()); 
        $ this -> _streamQuery ( "QUIT" ); 
        fclose ( $ this -> stream ); 
        
        $ code  =! empty ( $ code2 )? $ code2 : $ code ; 
        interruptor ( código $ ) {  
            caso  '250'
            / **  
             * http://www.ietf.org/rfc/rfc0821.txt  
             * 250 Acción de correo solicitada bien, completada  
             * dirección de correo electrónico aceptada  
             * /  
            caso  '450' 
            caso  '451' 
            caso  '452' 
                / **  
                 * http://www.ietf.org/rfc/rfc0821.txt  
                 * 450 Acción solicitada no realizada: el servidor de correo remoto  
                 * no desea aceptar correo de su servidor por  
                 * alguna razón (dirección IP, lista negra, etc.)  
                 * Gracias Nicht Lieb. 
                 * 451 Acción solicitada abortada: error local en el procesamiento  
                 * 452 Acción solicitada no tomada: almacenamiento insuficiente del sistema  
                 * la dirección de correo electrónico estaba en la lista gris (o se produjo algún error temporal en el MTA)  
                 * creo que el correo electrónico existe  
                 * /  
                return  TRUE ; 
            caso  '550' : 
                devolver  FALSO 
            por defecto:  
                devuelve  FALSO 
        }  
    }  

    / **  
     * escribe el contenido de la cadena en el flujo de archivos al que apunta el manejador 
     * Si se produce un error, devuelve FALSO. 
     * @access protected  
     * @param string $ string La cadena que se va a escribir  
     * @return string Devuelve un código de resultado, como un entero. 
     * /  
    función protegida  _streamQuery ( $ consulta ) {  
        $ esto -> edebug ( $ consulta ); 
        devuelve  stream_socket_sendto ( $ this -> stream $ query  self :: CRLF ); 
    }  

    / **  
     * Lee toda la línea de la respuesta y analízala. 
     * Si ocurre un error, devuelve FALSE  
     * @access protected  
     * @return string Respuesta  
     * /  
    función protegida  _streamResponse ( $ timed  0 ) {  
        $ reply  stream_get_line ( $ this -> stream 1 ); 
        $ status  stream_get_meta_data ( $ this -> stream ); 

        if (! empty ( $ status [ 'timed_out' ])) {  
            $ this -> edebug ( "¡Se agotó el tiempo de espera al esperar datos! (timeout { $ this -> stream_timeout }  segundos) " );  
        }  

        if ( $ reply  ===  FALSE  &&  $ status [ 'timed_out' ] &&  $ timed  $ this -> stream_timeout_wait ) {  
            return  $ this -> _streamResponse ( $ timed  $ this -> stream_timeout );  
        }  


        if ( $ reply  ! ==  FALSE  &&  $ status [ 'unread_bytes' ]>  0 ) {  
            $ reply  . =  Stream_get_line ( $ this -> stream $ status [ 'unread_bytes' ],  self :: CRLF ); 
        }  
        $ this -> edebug ( $ reply ); 
        devuelve  $ respuesta 
    }  

    / **  
     * Obtenga el código de respuesta de Response  
     * @param string $ str  
     * @return string  
     * /  
    protected function  _streamCode ( $ str ) {  
        preg_match ('/ ^ (? <code> [0-9] {3} ) (\ s | -) (. *) $ / ims' $ str $ coincidencias ); 
        $ code  = isset ( $ coincide con [ 'code' ])? $ coincide [ 'código' ]:  falso 
        devuelve  $ código 
    }  


/ **  
 * controlador de excepciones VerifyEmail  
 * / la  clase  verifyEmailException  extiende la  excepción  

    / **  
     * Salida de mensaje de error Prettify  
     * @return string  
     * /  
    public function  errorMessage () { 
        $ errorMsg $ esto -> getMessage (); 
        devuelve  $ errorMsg 
    }  


?>

Uso

La biblioteca VerifyEmail es fácil de usar para validar la dirección de correo electrónico usando PHP.
  • Inicialice la clase de la biblioteca usando VerifyEmail().
  • Configure el tiempo de espera, la depuración y la dirección de correo electrónico del remitente.
  • Llame a la check()función y pase la dirección de correo electrónico que desea validar.
    • Devuelve VERDADERO, si la dirección de correo electrónico dada es válida y real. Además, indica que el dominio de este correo electrónico existe y que el usuario es válido.
    • Devuelve FALSE, si la dirección de correo electrónico dada no es válida y no existe.
  • Si la función check () devuelve FALSE, puede verificar el correo electrónico con la función validate () para verificar si el formato del correo electrónico es válido pero el usuario no existe en el dominio.
<? php 
// Incluir el archivo de biblioteca require_once  'VerifyEmail.class.php' 
// Inicializar clase de biblioteca $ mail  = new  VerifyEmail (); 
// Establecer el valor de tiempo de espera en la secuencia $ mail -> setStreamTimeoutWait ( 20 ); 
// Establecer el modo de salida de depuración $ mail -> Depurar VERDADERO $ mail -> Debugoutput 'html' 
// Establecer la dirección de correo electrónico para la solicitud SMTP $ mail -> setEmailFrom ( 'from@email.com' ); 
// correo electrónico para comprobar$ email  'email@example.com' 
// Compruebe si el correo electrónico es válido y existe si ( $ mail -> check ( $ email )) {  
    echo  'Email & lt;' . $ email . '& gt; es existir! ' 
} elseif ( verifyEmail :: validate ( $ email )) {  
    echo  'Email & lt;' . $ email . '& gt; Es válido, pero no existe! 
} else {  
    echo  'Email & lt;' . $ email . '& gt; No es válido y no existe! '

?>

Acerca de: Programator

Somos Instinto Programador

0 comentarios:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

Con tecnología de Blogger.