Validando una dirección de correo-e

[[rretamar]]

Una función para comprobar una dirección de correo electrónico ingresada, de manera muy estricta. Funciones de este tipo hay varias, esta de la más completa que encontré. Leer código bien escrito es un placer, y Object Pascal lo hace más agradable aún.

Fuente: http://www.howtodothings.com/compute...in-delphi.html

Código Delphi [-]
Function ValidEmail(email: String): Boolean;
  // Returns True if the email address is valid
  // Author: Ernesto D'Spirito
Const
  // Valid characters in an "atom"
  atom_chars = [#33..#255] - ['(', ')', '<', '>', '@', ',', ';', ':',
    '\', '/', '"', '.', '[', ']', #127];
  // Valid characters in a "quoted-string"
  quoted_string_chars = [#0..#255] - ['"', #13, '\'];
  // Valid characters in a subdomain
  letters = ['A'..'Z', 'a'..'z'];
  letters_digits = ['0'..'9', 'A'..'Z', 'a'..'z'];
  subdomain_chars = ['-', '0'..'9', 'A'..'Z', 'a'..'z'];
Type
  States = (STATE_BEGIN, STATE_ATOM, STATE_QTEXT, STATE_QCHAR,
    STATE_QUOTE, STATE_LOCAL_PERIOD, STATE_EXPECTING_SUBDOMAIN,
    STATE_SUBDOMAIN, STATE_HYPHEN);
Var
  State: States;
  i, n, subdomains: Integer;
  c: Char;
Begin
  State := STATE_BEGIN;
  n := Length(email);
  i := 1;
  subdomains := 1;
  While (i <= n) Do
  Begin
    c := email[i];
    Case State Of
      STATE_BEGIN:
        If c In atom_chars Then
          State := STATE_ATOM
        Else If c = '"' Then
          State := STATE_QTEXT
        Else
          break;
      STATE_ATOM:
        If c = '@' Then
          State := STATE_EXPECTING_SUBDOMAIN
        Else If c = '.' Then
          State := STATE_LOCAL_PERIOD
        Else If Not (c In atom_chars) Then
          break;
      STATE_QTEXT:
        If c = '\' Then
          State := STATE_QCHAR
        Else If c = '"' Then
          State := STATE_QUOTE
        Else If Not (c In quoted_string_chars) Then
          break;
      STATE_QCHAR:
        State := STATE_QTEXT;
      STATE_QUOTE:
        If c = '@' Then
          State := STATE_EXPECTING_SUBDOMAIN
        Else If c = '.' Then
          State := STATE_LOCAL_PERIOD
        Else
          break;
      STATE_LOCAL_PERIOD:
        If c In atom_chars Then
          State := STATE_ATOM
        Else If c = '"' Then
          State := STATE_QTEXT
        Else
          break;
      STATE_EXPECTING_SUBDOMAIN:
        If c In letters Then
          State := STATE_SUBDOMAIN
        Else
          break;
      STATE_SUBDOMAIN:
        If c = '.' Then
        Begin
          Inc(subdomains);
          State := STATE_EXPECTING_SUBDOMAIN;
        End
        Else If c = '-' Then
          State := STATE_HYPHEN
        Else If Not (c In letters_digits) Then
          break;
      STATE_HYPHEN:
        If c In letters_digits Then
          State := STATE_SUBDOMAIN
        Else If c <> '-' Then
          break;
    End;
    Inc(i);
  End;
  If i <= n Then
    Result := False
  Else
    Result := (State = STATE_SUBDOMAIN) And (subdomains >= 2);
End;

[jhonny]

¿Esta es aún mejor que las que hay utilizando Expresiones Regulares?, si es así... ¿Cuál sería la razón?

[Delphifandev]

No veo por qué esa función sería mejor que una buena expresión regular. Me parece que lo complicas demasiado para nada.

[mamcx]

El codigo aqui es una maquina de estado. Una expresion regular eso es lo que genera (en formato DFA), aunque existe una mejor manera si no hay necesidad de backtraking:

https://swtch.com/~rsc/regexp/regexp1.html

Osea: Es codigo especifico hecho a mnos, presumiblemente (porque faltaria chequearlo) mas eficiente que el generado a maquina... y ademas no tienen dependencias...

[0x90]

Definitivamente como hay otros compañeros que han objetado, hay maneras mucho mas sencillas para validar un correo electronico, y en cuanto a validación se refiere RegEX (Expresión Regular) es la mejor solución/opción al caso.

Con muy poco esfuerzo podremos tener un verificador de Correos Electronicos en unos pocos minutos.

Requerimientos:

Libreria: TPerlRegEx

Veamos como podemos validar un Correo Electronico en un formulario basico:

(x1) Edit = edt1
(x1) Botón = btn1
(x1) Label = lbl1

Variables Globales:

var
  parser: TPerlRegEx;
  list: TStringList;
  found: boolean;
  str: string;
  i: Integer;
  strToMatch: string;

Codigo:

try
    list := TStringList.Create;
    try
      parser := TPerlRegEx.Create;
      try
        parser.RegEx := '(^[\w-]+(?:\.[\w-]+)*@(?:[\w-]+\.)+[a-zA-Z]{2,7}$)';
        strToMatch := edt1.Text;
        parser.Subject := strToMatch;
        found := parser.Match;
        if found = True then
        begin
           lbl1.Caption := 'VALIDO!';
        end
        else
        begin
           lbl1.Caption := 'INVALIDO!';
        end;
      finally
        parser.Free;
      end;
    finally
      list.Free;
    end;
  except
    on E: Exception do
    Application.MessageBox(PChar(E.Message),'Verificador de Correos Electronicos', MB_OK);
  end;

Nota: Como no puedo aun poner links ni imagenes, no puedo poner como se ve mi formulario, ni dar referencias de donde saque la información, pero si saben buscar en Google, sabrán buscar por aqui y por allá y darán con el martillo en el clavo

Cabe mencionar que la Expresión Regular que se utiliza en este caso, identifica y reconoce el 99.99% de los Correos Electronicos!

[[movorack]]

Muy útil para mi que manejo aún el Delphi 5 y en este IDE no tenemos expresiones regulares.

[[Delphius]]

Empezado por 0x90

Definitivamente como hay otros compañeros que han objetado, hay maneras mucho mas sencillas para validar un correo electronico, y en cuanto a validación se refiere RegEX (Expresión Regular) es la mejor solución/opción al caso.

Con muy poco esfuerzo podremos tener un verificador de Correos Electronicos en unos pocos minutos.

Requerimientos:

Libreria: TPerlRegEx

Veamos como podemos validar un Correo Electronico en un formulario basico:

(x1) Edit = edt1
(x1) Botón = btn1
(x1) Label = lbl1

Variables Globales:

var
  parser: TPerlRegEx;
  list: TStringList;
  found: boolean;
  str: string;
  i: Integer;
  strToMatch: string;

Codigo:

try
    list := TStringList.Create;
    try
      parser := TPerlRegEx.Create;
      try
        parser.RegEx := '(^[\w-]+(?:\.[\w-]+)*@(?:[\w-]+\.)+[a-zA-Z]{2,7}$)';
        strToMatch := edt1.Text;
        parser.Subject := strToMatch;
        found := parser.Match;
        if found = True then
        begin
           lbl1.Caption := 'VALIDO!';
        end
        else
        begin
           lbl1.Caption := 'INVALIDO!';
        end;
      finally
        parser.Free;
      end;
    finally
      list.Free;
    end;
  except
    on E: Exception do
    Application.MessageBox(PChar(E.Message),'Verificador de Correos Electronicos', MB_OK);
  end;

Nota: Como no puedo aun poner links ni imagenes, no puedo poner como se ve mi formulario, ni dar referencias de donde saque la información, pero si saben buscar en Google, sabrán buscar por aqui y por allá y darán con el martillo en el clavo

Cabe mencionar que la Expresión Regular que se utiliza en este caso, identifica y reconoce el 99.99% de los Correos Electronicos!

¿Pero quien carajo sos vos para decir en el título de tu post: NO, NO, NO. Y que así no se hace?
Es una propuesta de tantas. Si se tratara de un error conceptual bueno, te acepto la corrección, pero no es el caso.
Es una alternativa y propuesta PERSONAL a considerar y como tal no puede ser descartada. Sobre todo si quien pretende descartarla es un usuario que apenas lleva 2 mensajitos y viene prepotente. Acá suficiente tiene el foro con ciertos usuarios prepotentes , entre ellos me incluyo ¿está claro?

De que usando expresiones regulares se puede, se puede. Haciéndolo por una máquina de estados, TAMBIÉN se puede.
¿Cuál de las dos es más eficiente? Para sacarnos las dudas concretamente se debería hacer una prueba de perfomance.

Ahora, lo que si me animo a decir que lapropuesta basada en la máquina de estados va a los bifes... directo a la problemática.
Cuando uno usa expresiones regulares, indirectamente está generando una máquina de estados. De hecho, cuando se crea/carga la expresión regular el componente/clase va a necesitar primero armar la máquina de estados y luego procede a analizar la cadena a ver si la cumple.

En última ambos procesos son equivalentes, pero la primera opción es mucho más directa. No descarten que es posible que les sace algunos ciclos de procesador de ventaja a la propuesta de expresiones regulares.

Saludos,

[Casimiro Notevi]

Empezado por Delphius

En última ambos procesos son equivalentes, pero la primera opción es mucho más directa. No descarten que es posible que les sace algunos ciclos de procesador de ventaja a la propuesta de expresiones regulares.

Sería lo más lógico. ya que la "expresión regular" tendrá que ser analizada, y en ese caso acabará en alguna función del tipo "ValidarEmail".

[roman]

Podrá ser más directo pero también es reinventar la rueda. Yo prefiero la expresión regular a lidiar yo mismo con la máquina de estados.

pd: No hay punto en la guía de estilo que dicte un mínimo de mensajes para poder opinar

LineComment Saludos

[[Al González]]

Ya que esto está por caer al caldero de los debates, pienso que sería interesante conocer un caso real de programación en Delphi donde habiendo la necesidad de validar direcciones de correo electrónico, y teniéndose al alcance el tipo nativo TRegEx de las versiones modernas, se haya optado por otro mecanismo en aras de un consumo óptimo de recursos (tiempo o memoria), con la respectiva explicación de qué diferencia de consumo de recursos se obtuvo en las pruebas y cómo sin esa optimización el proceso implementado se veía seriamente comprometido.

Ojo: No digo que no exista el caso.

[roman]

Empezado por Al González

Ojo: No digo que no exista el caso.

Pero con tantas especificaciones parecería que sí.

Pd: por cierto Al, la expresión "más óptimo" no es correcta

LineComment Saludos

[Casimiro Notevi]

¿A partir de qué versión existe regex?

[roman]

Olvidé comentar en el mensaje #9 -y es que nunca había visto este hilo- que independientemente de cuál técnica sea mejor, el ejemplo de rretamar luce bonito para entender un poco lo qué es una máquina de estado y cómo se implementa.

LineComment Saludos

[roman]

Empezado por Casimiro Notevi

¿A partir de qué versión existe regex?

Creo que a partir del las XE. Pero hay bibliotecas para versiones anteriores.

LineComment Saludos

[[Al González]]

Empezado por roman

por cierto Al, la expresión "más óptimo" no es correcta

Cierto, expresión corregida.

Empezado por roman

independientemente de cuál técnica sea mejor, el ejemplo de rretamar luce bonito para entender [...]

Rescatado el hilo, no hervirá por ahora.

[Ñuño Martínez]

Pues yo prefiero el código en Pascal a las expresiones regulares. Principalmente porque me he leído chorrocientosmil artículos, tutoriales y cursos que prometían enseñar fácilmente cómo funcionan, y sigo sin tener ni pajolera idea, porque siempre que he creído entenderlo he intentado crear una y jamás lo he conseguido. Como mucho, he conseguido hacer algún cambio (pequeño) a alguna expresión regular pre-existente, pero nada más.

Además, es código escrito por Ernesto D'Spirito y eso ya me vale. ¡Anda que no he aprendido cosas gracias al trabajo de ese hombre!

[Casimiro Notevi]

Empezado por Ñuño Martínez

Pues yo prefiero el código en Pascal a las expresiones regulares. Principalmente porque me he leído chorrocientosmil artículos, tutoriales y cursos que prometían enseñar fácilmente cómo funcionan, y sigo sin tener ni pajolera idea, porque siempre que he creído entenderlo he intentado crear una y jamás lo he conseguido. Como mucho, he conseguido hacer algún cambio (pequeño) a alguna expresión regular pre-existente, pero nada más.

parser.RegEx := '(^[\w-]+(?:\.[\w-]+)*@(?:[\w-]+\.)+[a-zA-Z]{2,7}$)';

Pero si está muy claro, lo entiende hasta un niño de 5 años cualquiera, que conozca Unlambda, Malbolge o Brainfuck

Unlambda
```s``sii`ki
``s``s`ks
``s``s`ks``s`k`s`kr
``s`k`si``s`k`s`k
`d````````````.H.o.l.a.,. .m.u.n.d.o.!
k
k
`k``s``s`ksk`k.*

Malbolge
(=<`:9876Z4321UT.-Q+*)M'&%$H"!~}|Bzy?=|{z]KwZY44Eq0/{mlk**
hKs_dG5[m_BA{?-Y;;Vb'rR5431M}/.zHGwEDCAA@98\6543W10/.R,+O<

Brainfuck
+++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.

[roman]

Sí, no son fáciles, pero tampoco son imposibles. Para mi, una expresión regular es de sólo-escritura, las puedes escribir conforme las vas creando pero cuesta trabajo leerlas.

Yo, para validar emails uso esta:

/^[A-Z0-9_-]+(\.[A-Z0-9_-]+)*@[A-Z0-9_-]+(\.[A-Z0-9_-]+)*\.[A-Z]{2,3}$/i

Para irla entendiendo, omito las diagonales invertidas \ que sirven para escapar:

/^[A-Z0-9_-]+(.[A-Z0-9_-]+)*@[A-Z0-9_-]+(.[A-Z0-9_-]+)*.[A-Z]{2,3}$/i

Las diagonales / sólo delimitan la expresión y lo que va después es un modificador global, en este caso i que significa case insensitive. El caret ^ significa que debe coincidir con el principio de la cadena y el $ que debe coincidir con el final.

Luego vas separando las partes:

1.

Uno o más de los caracteres dentro de los corchetes
(letras, números, guiones bajos y medios):

[A-Z0-9_-]+(.[A-Z0-9_-]+)*@[A-Z0-9_-]+(.[A-Z0-9_-]+)*.[A-Z]{2,3}

2.

0 o más veces lo que está entre paréntesis
(un punto seguido de uno o más letras, números o guiones):

[A-Z0-9_-]+(.[A-Z0-9_-]+)*@[A-Z0-9_-]+(.[A-Z0-9_-]+)*.[A-Z]{2,3}

3.

La arroba @

[A-Z0-9_-]+(.[A-Z0-9_-]+)*@[A-Z0-9_-]+(.[A-Z0-9_-]+)*.[A-Z]{2,3}

4.

Uno o más de letras, números o guiones (como en 1.)

[A-Z0-9_-]+(.[A-Z0-9_-]+)*@[A-Z0-9_-]+(.[A-Z0-9_-]+)*.[A-Z]{2,3}

5.

Igual que en 2.

[A-Z0-9_-]+(.[A-Z0-9_-]+)*@[A-Z0-9_-]+(.[A-Z0-9_-]+)*.[A-Z]{2,3}

6.

Un punto seguido de 2 o tres letras:

[A-Z0-9_-]+(.[A-Z0-9_-]+)*@[A-Z0-9_-]+(.[A-Z0-9_-]+)*.[A-Z]{2,3}

En términos más humanos: si entendemos por un identificador válido cualquier cosa que tenga letras, números o guiones, éste lo representamos en la expresión regular por [A-Z0-9_-]+. Entonces, conceptualmente hablando, la expresión regular es:

Antes de la arroba: uno o más identificadores separados por puntos
Después de la arroba: uno o más identificadores separados por puntos y dos o tres letras separadas del resto por un punto (o sea, el .com, .org, .mx, etc.)

Y, de hecho, es de esta representación conceptual de donde parte uno y de ahí vas construyendo la expresión.

Lo que uno tiene que tener en cuenta es:

1. Hay muchas formas de construir una expresión regular para un fin específico.
2. Por tanto, nadie puede decir ÉSTA es la buena.
3. No siempre es necesario abarcar todos y cada uno de los casos.

Por ejemplo, la expresión regular que uso, seguramente fallará en algunos casos, pero me ha funcionado sin problemas hasta ahora y a lo sumo tendré un usuario cada dos años que me diga: oye tu sistema no acepta mi correo. Nadie abarca todos los casos. Ni siquiera GMail (que es de donde basé mi expresión). Por ejemplo, ¿sabían que el RFC del email incluye comentarios ? Estoy seguro que nadie valida eso .

También es cierto que hay expresiones más complejas que incluye las referencias hacia atrás y hacia adelante pero las va uno entendiendo conforme escribes la expresión.

El manual de PHP explica muy claramente el uso de expresiones PCRE, que son las más comunes y puede aplicarse a otros ámbitos como Delphi.

LineComment Saludos

[[Al González]]

Román: ¡Eso amerita like, tweet, picarle al botón reputación, puntos adicionales de poder y una Montejo! (O la cerveza que usted prefiera).

Gracias por el esmerado aporte.

[roman]

Con la cerveza me basta Victoria, por favor

LineComment Saludos