Club Delphi  
    FTP   CCD     Buscar   Trucos   Trabajo   Foros

Retroceder   Foros Club Delphi > Otros temas > Trucos
Registrarse FAQ Miembros Calendario Guía de estilo Buscar Temas de Hoy Marcar Foros Como Leídos

Los mejores trucos

Respuesta
 
Herramientas Buscar en Tema Desplegado
  #1  
Antiguo 02-07-2016
Avatar de rretamar
[rretamar] rretamar is offline
Miembro Premium
 
Registrado: ago 2006
Ubicación: San Francisco, Córdoba, Argentina
Posts: 1.101
Poder: 13
rretamar Va camino a la fama
Validando una dirección de correo-e

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;
__________________
Lazarus Codetyphon : Desarrollo de aplicaciones Object Pascal, libre y multiplataforma.
Responder Con Cita
  #2  
Antiguo 02-07-2016
Avatar de jhonny
jhonny jhonny is offline
Jhonny Suárez
 
Registrado: may 2003
Ubicación: Colombia
Posts: 6.944
Poder: 21
jhonny Va camino a la fama
¿Esta es aún mejor que las que hay utilizando Expresiones Regulares?, si es así... ¿Cuál sería la razón?
__________________
Lecciones de mi Madre. Tema: modificación del comportamiento, "Pará de actuar como tu padre!"

http://www.purodelphi.com/
Responder Con Cita
  #3  
Antiguo 24-07-2016
Delphifandev Delphifandev is offline
Miembro
 
Registrado: jul 2016
Posts: 10
Poder: 0
Delphifandev Va por buen camino
No veo por qué esa función sería mejor que una buena expresión regular. Me parece que lo complicas demasiado para nada.
Responder Con Cita
  #4  
Antiguo 24-07-2016
Avatar de mamcx
mamcx mamcx is offline
Moderador
 
Registrado: sep 2004
Ubicación: Medellín - Colombia
Posts: 3.403
Poder: 18
mamcx Va camino a la famamamcx Va camino a la fama
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...
__________________
Nuevo Blog.
Ahora en Twitter!.
Responder Con Cita
  #5  
Antiguo 24-11-2016
0x90 0x90 is offline
Registrado
 
Registrado: jun 2016
Posts: 5
Poder: 0
0x90 Va por buen camino
NO, que NO y que NO!

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:
Código:
Libreria: TPerlRegEx
Veamos como podemos validar un Correo Electronico en un formulario basico:
Código:
(x1) Edit = edt1
(x1) Botón = btn1
(x1) Label = lbl1
Variables Globales:
Código:
var
  parser: TPerlRegEx;
  list: TStringList;
  found: boolean;
  str: string;
  i: Integer;
  strToMatch: string;
Codigo:
Código:
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!
Responder Con Cita
  #6  
Antiguo 24-11-2016
Avatar de movorack
[movorack] movorack is offline
Miembro
 
Registrado: feb 2007
Ubicación: Bogotá - Colombia
Posts: 1.015
Poder: 12
movorack Va camino a la fama
Muy útil para mi que manejo aún el Delphi 5 y en este IDE no tenemos expresiones regulares.
__________________
Buena caza y buen remar... http://mivaler.blogspot.com
Responder Con Cita
  #7  
Antiguo 24-11-2016
Avatar de Delphius
[Delphius] Delphius is offline
Miembro Premium
 
Registrado: jul 2004
Ubicación: Salta, Argentina
Posts: 5.598
Poder: 19
Delphius Va camino a la fama
Cita:
Empezado por 0x90 Ver Mensaje
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:
Código:
Libreria: TPerlRegEx
Veamos como podemos validar un Correo Electronico en un formulario basico:
Código:
(x1) Edit = edt1
(x1) Botón = btn1
(x1) Label = lbl1
Variables Globales:
Código:
var
  parser: TPerlRegEx;
  list: TStringList;
  found: boolean;
  str: string;
  i: Integer;
  strToMatch: string;
Codigo:
Código:
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,
__________________
Delphius
[Guia de estilo][Buscar]
Responder Con Cita
  #8  
Antiguo 24-11-2016
Avatar de Casimiro Notevi
Casimiro Notevi Casimiro Notevi is offline
Moderador
 
Registrado: sep 2004
Ubicación: En algún lugar.
Posts: 27.414
Poder: 10
Casimiro Notevi Tiene un aura espectacularCasimiro Notevi Tiene un aura espectacular
Cita:
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".

Última edición por roman fecha: 24-11-2016 a las 17:31:36. Razón: Corregir la etiqueta [quote] ¡Novatos! :D
Responder Con Cita
  #9  
Antiguo 24-11-2016
Avatar de roman
roman roman is offline
Moderador
 
Registrado: may 2003
Ubicación: Ciudad de México
Posts: 20.107
Poder: 10
roman Tiene un aura espectacularroman Tiene un aura espectacular
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
Responder Con Cita
  #10  
Antiguo 24-11-2016
Avatar de Al González
[Al González] Al González is offline
In .pas since 1991
 
Registrado: may 2003
Posts: 5.486
Poder: 22
Al González Es un diamante en brutoAl González Es un diamante en brutoAl González Es un diamante en bruto
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.
__________________
Twitter
Código
Blog
Móvil y WhatsApp: +52 1 2711260117

Última edición por Al González fecha: 24-11-2016 a las 20:15:03. Razón: Corregir expresión
Responder Con Cita
  #11  
Antiguo 24-11-2016
Avatar de roman
roman roman is offline
Moderador
 
Registrado: may 2003
Ubicación: Ciudad de México
Posts: 20.107
Poder: 10
roman Tiene un aura espectacularroman Tiene un aura espectacular
Cita:
Empezado por Al González Ver Mensaje
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
Responder Con Cita
  #12  
Antiguo 24-11-2016
Avatar de Casimiro Notevi
Casimiro Notevi Casimiro Notevi is offline
Moderador
 
Registrado: sep 2004
Ubicación: En algún lugar.
Posts: 27.414
Poder: 10
Casimiro Notevi Tiene un aura espectacularCasimiro Notevi Tiene un aura espectacular
¿A partir de qué versión existe regex?
Responder Con Cita
  #13  
Antiguo 24-11-2016
Avatar de roman
roman roman is offline
Moderador
 
Registrado: may 2003
Ubicación: Ciudad de México
Posts: 20.107
Poder: 10
roman Tiene un aura espectacularroman Tiene un aura espectacular
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
Responder Con Cita
  #14  
Antiguo 24-11-2016
Avatar de roman
roman roman is offline
Moderador
 
Registrado: may 2003
Ubicación: Ciudad de México
Posts: 20.107
Poder: 10
roman Tiene un aura espectacularroman Tiene un aura espectacular
Cita:
Empezado por Casimiro Notevi Ver Mensaje
¿A partir de qué versión existe regex?
Creo que a partir del las XE. Pero hay bibliotecas para versiones anteriores.

LineComment Saludos
Responder Con Cita
  #15  
Antiguo 24-11-2016
Avatar de Al González
[Al González] Al González is offline
In .pas since 1991
 
Registrado: may 2003
Posts: 5.486
Poder: 22
Al González Es un diamante en brutoAl González Es un diamante en brutoAl González Es un diamante en bruto
Cita:
Empezado por roman Ver Mensaje
por cierto Al, la expresión "más óptimo" no es correcta
Cierto, expresión corregida.

Cita:
Empezado por roman Ver Mensaje
independientemente de cuál técnica sea mejor, el ejemplo de rretamar luce bonito para entender [...]


Rescatado el hilo, no hervirá por ahora.
__________________
Twitter
Código
Blog
Móvil y WhatsApp: +52 1 2711260117
Responder Con Cita
  #16  
Antiguo 25-11-2016
Avatar de Ñuño Martínez
Ñuño Martínez Ñuño Martínez is offline
Moderador
 
Registrado: jul 2006
Ubicación: Ciudad Catedral, Españistán
Posts: 5.618
Poder: 18
Ñuño Martínez Va camino a la famaÑuño Martínez Va camino a la fama
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!
__________________
Proyectos actuales --> Burdjia Components|http://gesbit.sf.net/
Responder Con Cita
  #17  
Antiguo 25-11-2016
Avatar de Casimiro Notevi
Casimiro Notevi Casimiro Notevi is offline
Moderador
 
Registrado: sep 2004
Ubicación: En algún lugar.
Posts: 27.414
Poder: 10
Casimiro Notevi Tiene un aura espectacularCasimiro Notevi Tiene un aura espectacular
Cita:
Empezado por Ñuño Martínez Ver Mensaje
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.

Código:
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
Cita:
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.*
Cita:
Malbolge
(=<`:9876Z4321UT.-Q+*)M'&%$H"!~}|Bzy?=|{z]KwZY44Eq0/{mlk**
hKs_dG5[m_BA{?-Y;;Vb'rR5431M}/.zHGwEDCAA@98\6543W10/.R,+O<
Cita:
Brainfuck
+++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
Responder Con Cita
  #18  
Antiguo 25-11-2016
Avatar de roman
roman roman is offline
Moderador
 
Registrado: may 2003
Ubicación: Ciudad de México
Posts: 20.107
Poder: 10
roman Tiene un aura espectacularroman Tiene un aura espectacular
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:

Código:
/^[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:

Código:
/^[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.
Código:
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.
Código:
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.
Código:
La arroba @

[A-Z0-9_-]+(.[A-Z0-9_-]+)*@[A-Z0-9_-]+(.[A-Z0-9_-]+)*.[A-Z]{2,3}
4.
Código:
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.
Código:
Igual que en 2.

[A-Z0-9_-]+(.[A-Z0-9_-]+)*@[A-Z0-9_-]+(.[A-Z0-9_-]+)*.[A-Z]{2,3}
6.
Código:
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
Responder Con Cita
  #19  
Antiguo 25-11-2016
Avatar de Al González
[Al González] Al González is offline
In .pas since 1991
 
Registrado: may 2003
Posts: 5.486
Poder: 22
Al González Es un diamante en brutoAl González Es un diamante en brutoAl González Es un diamante en bruto
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.
__________________
Twitter
Código
Blog
Móvil y WhatsApp: +52 1 2711260117
Responder Con Cita
  #20  
Antiguo 25-11-2016
Avatar de roman
roman roman is offline
Moderador
 
Registrado: may 2003
Ubicación: Ciudad de México
Posts: 20.107
Poder: 10
roman Tiene un aura espectacularroman Tiene un aura espectacular
Con la cerveza me basta Victoria, por favor

LineComment Saludos
Responder Con Cita
Respuesta


Herramientas Buscar en Tema
Buscar en Tema:

Búsqueda Avanzada
Desplegado

Normas de Publicación
no Puedes crear nuevos temas
no Puedes responder a temas
no Puedes adjuntar archivos
no Puedes editar tus mensajes

El código vB está habilitado
Las caritas están habilitado
Código [IMG] está habilitado
Código HTML está deshabilitado
Saltar a Foro

Temas Similares
Tema Autor Foro Respuestas Último mensaje
Error: too much mail from (dirección ip) enviando correo masivo Gregorio Cíber Internet 2 10-07-2015 13:43:48
Como Saber si una Dirección de Correo es Válida???? AGAG4 Internet 30 19-07-2011 18:36:48
Pueden Ver Mi Direccion De Correo? CITHALI ACERMA Seguridad 12 18-06-2006 22:49:15
El correo que mando a una direccion de hotmail no llega bien URBANO Internet 1 27-04-2005 07:53:49
Ejecutar cliente de correo pasandole la direccion del destinatario Durbed API de Windows 1 19-10-2004 12:34:00


La franja horaria es GMT +2. Ahora son las 05:39:53.


Powered by vBulletin® Version 3.6.8
Copyright ©2000 - 2017, Jelsoft Enterprises Ltd.
Traducción al castellano por el equipo de moderadores del Club Delphi
Copyright 1996-2007 Club Delphi