cocoa touch - validate - ¿Cuáles son las mejores prácticas para validar direcciones de correo electrónico en iOS 2.0?

validate textfield swift 4

Question

¿Cuál es la forma más limpia de validar una dirección de correo electrónico que ingresa un usuario en iOS 2.0?

NOTA : Esta es una pregunta histórica que es específica de iOS 2.0 y, debido a su antigüedad y al número de preguntas relacionadas, no puede retirarse y NO DEBE cambiarse a una pregunta "moderna".

Answer 1

Aquí hay una extensión de String que valida un correo electrónico en Swift.

extension String {

    func isValidEmail() -> Bool {
        let stricterFilter = false
        let stricterFilterString = "^[A-Z0-9a-z//._%+-]+@([A-Za-z0-9-]+//.)+[A-Za-z]{2,4}$"
        let laxString = "^.+@([A-Za-z0-9-]+//.)+[A-Za-z]{2}[A-Za-z]*$"
        let emailRegex = stricterFilter ? stricterFilterString : laxString
        let emailTest = NSPredicate(format: "SELF MATCHES %@", emailRegex)
        return emailTest.evaluate(with: self)
    }
}

Copiado de la respuesta a: Verifique que una dirección de correo electrónico sea válida en iOS

Answer 2

Descubrí que usar una expresión regular funciona bastante bien para validar una dirección de correo electrónico.

La principal desventaja de las expresiones regulares del curso es el mantenimiento, así que comente como nunca antes lo había comentado. Te lo prometo, si no lo haces, desearás que lo hicieras cuando vuelvas a la expresión después de unas semanas.

Aquí hay un enlace a una buena fuente, http://www.regular-expressions.info/email.html .

Answer 3

Desenterrando la tierra, pero me SHEmailValidator con SHEmailValidator que hace un trabajo perfecto y tiene una interfaz agradable.

Answer 4

Esta función es simple y, sin embargo, verifica la dirección de correo electrónico más a fondo. Por ejemplo, según RFC2822, una dirección de correo electrónico no debe contener dos períodos en una fila, como firstname ... lastname @ domain..com

También es importante usar anclajes en expresiones regulares como se ve en esta función. Sin anclas, la siguiente dirección de correo electrónico se considera válida: primero; nombre) [email protected] (blah porque la sección [email protected] es válida, ignorando primero; name) al comienzo y (blah) al final. Anchors forzar motor de expresiones regulares para validar todo el correo electrónico.

Esta función usa NSPredicate que no existe en iOS 2. Lamentablemente, no puede ayudar al asker, pero con suerte ayudará a otros con las versiones más nuevas de iOS. Las expresiones regulares en esta función aún se pueden aplicar a RegExKitLite en iOS 2. Y para aquellos que usan iOS 4 o posterior, estas expresiones regulares se pueden implementar con NSRegularExpression.

- (BOOL)isValidEmail:(NSString *)email
{
    NSString *regex1 = @"//A[a-z0-9]+([-._][a-z0-9]+)*@([a-z0-9]+(-[a-z0-9]+)*//.)+[a-z]{2,4}//z";
    NSString *regex2 = @"^(?=.{1,64}@.{4,64}$)(?=.{6,100}$).*";
    NSPredicate *test1 = [NSPredicate predicateWithFormat:@"SELF MATCHES %@", regex1];
    NSPredicate *test2 = [NSPredicate predicateWithFormat:@"SELF MATCHES %@", regex2];
    return [test1 evaluateWithObject:email] && [test2 evaluateWithObject:email];
}

Ver validar la dirección de correo electrónico usando la expresión regular en Objective-C .

Answer 5

La mejor solución que he encontrado hasta ahora (y con la que terminé) es agregar RegexKitLite al proyecto que da acceso a expresiones regulares a través de categorías NSString.

Es bastante sencillo agregar al proyecto y, una vez en su lugar, cualquier lógica de validación de correo electrónico de expresión regular funcionará.

Answer 6

La respuesta a Usar una expresión regular para validar una dirección de correo electrónico explica en gran detalle que la gramática especificada en el RFC 5322 es demasiado complicada para las expresiones regulares primitivas.

Recomiendo un enfoque de analizador real como MKEmailAddress .

Como solución de expresiones regulares rápidas, vea esta modificación de DHValidation :

- (BOOL) validateEmail: (NSString *) candidate {
    NSString *emailRegex =
@"(?:[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])+)//])"; 
    NSPredicate *emailTest = [NSPredicate predicateWithFormat:@"SELF MATCHES[c] %@", emailRegex]; 

    return [emailTest evaluateWithObject:candidate];
}

Answer 7

Lee el RFC. Casi todos los que piensan que saben cómo analizar / limpiar / validar una dirección de correo electrónico están equivocados.

http://tools.ietf.org/html/rfc2822 sección 3.4.1 es muy útil. darse cuenta

dtext = NO-WS-CTL / ; Non white space controls %d33-90 / ; The rest of the US-ASCII %d94-126 ; characters not including "[", ; "]", or "/"

Sí, eso significa que +, '', etc. son todos de fiar.

Answer 8

Muchos sitios web brindan RegExes, pero conviene que los aprenda y los comprenda, así como también que verifique que lo que desea hacer se ajuste a sus necesidades dentro de la RFC oficial para formatos de direcciones de correo electrónico.

Para aprender RegEx, los idiomas interpretados pueden ser un gran simplificador y testbed. Rubular está basado en Ruby, pero es una buena forma rápida de probar y verificar: http://www.rubular.com/

Más allá de eso, compre la última edición del libro O''Reilly Mastering Regular Expressions. Querrá pasar el tiempo para comprender los primeros 3 o 4 capítulos. Todo después de eso construirá experiencia en el uso de RegEx altamente optimizado.

A menudo, una serie de RegExes más pequeños y fáciles de administrar es más fácil de mantener y depurar.

Answer 9

No deberías tratar de usar expresiones regulares para validar un correo electrónico. Con los TLD cambiantes, su validador es incompleto o inexacto. En su lugar, debe aprovechar las bibliotecas NSDataDetector de Apple, que tomarán una cadena y tratarán de ver si hay campos de datos conocidos (correos electrónicos, direcciones, fechas, etc.). ¡El SDK de Apple hará todo lo posible por mantenerse al día con los TLD y podrá aprovecharse de sus esfuerzos! :)

Además, si iMessage (o cualquier otro campo de texto) no cree que sea un correo electrónico, ¿debería considerar un correo electrónico?

Puse esta función en una categoría NSString , por lo que la cadena que estás probando es self .

- (BOOL)isValidEmail {
    // Trim whitespace first
    NSString *trimmedText = [self stringByTrimmingCharactersInSet:NSCharacterSet.whitespaceAndNewlineCharacterSet];
    if (self && self.length > 0) return NO;

    NSError *error = nil;
    NSDataDetector *dataDetector = [[NSDataDetector alloc] initWithTypes:NSTextCheckingTypeLink error:&error];
    if (!dataDetector) return NO;

    // This string is a valid email only if iOS detects a mailto link out of the full string
    NSArray<NSTextCheckingResult *> *allMatches = [dataDetector matchesInString:trimmedText options:kNilOptions range:NSMakeRange(0, trimmedText.length)];
    if (error) return NO;
    return (allMatches.count == 1 && [[[allMatches.firstObject URL] absoluteString] isEqual:[NSString stringWithFormat:@"mailto:%@", self]]);
}

o como una extensión de String rápida

extension String {
    func isValidEmail() -> Bool {
        let trimmed = self.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !trimmed.isEmpty, let dataDetector = try? NSDataDetector(types: NSTextCheckingResult.CheckingType.link.rawValue) else {
            return false
        }
        let allMatches = dataDetector.matches(in: trimmed, options: [], range: NSMakeRange(0, trimmed.characters.count))

        return allMatches.count == 1 && allMatches.first?.url?.absoluteString == "mailto:/(trimmed)"
    }
}

Answer 10

Si bien el enfoque en las expresiones regulares es bueno, pero este es solo el primer paso necesario. Hay otros pasos que también deben tenerse en cuenta para una buena estrategia de validación.

Dos cosas en mi cabeza son:

1. Validación DNS para asegurarse de que el dominio realmente exista.

2. Después de la validación dns, también puede optar por hacer una validación smtp. envíe una llamada al servidor smtp para ver si el usuario realmente existe.

De esta forma, puede detectar todo tipo de errores de usuario y asegurarse de que sea un correo electrónico válido.

Answer 11

Un buen comienzo es decidir qué quieres y qué no quieres aceptar como dirección de correo electrónico.

El 99% de las direcciones de correo electrónico se ven así: [email protected] o [email protected]

Sin embargo, es técnicamente legal tener una dirección de correo electrónico como esta: f !#$%&''*+-/=?^_ {|} ~ "Ha!" @ Com

Probablemente haya solo un puñado de correos electrónicos válidos en el mundo para dominios de nivel superior, y casi nadie usa la mayoría de esos otros personajes (especialmente comillas y marcadores), por lo que puede suponer que estas son todas cosas inválidas que hacer. Pero deberías hacerlo como una decisión consciente.

Más allá de eso, haz lo que dice Pablo e intenta hacer coincidir la entrada con una expresión regular como esta: ^ [A-Z0-9 ._% + -] + @ [A-Z0-9 .-] +. [AZ] { 2,} $

Ese coincidirá con la dirección de correo electrónico de casi todos.

Answer 12

// Method Call
NSString *email = @"Your Email string..";

BOOL temp = [self validateEmail:email];

if(temp)
{
// Valid
}
else
{
// Not Valid
}
// Method description

- (BOOL) validateEmail: (NSString *) email {
    NSString *emailRegex = @"[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+//.[A-Za-z]{2,4}";
    NSPredicate *emailTest = [NSPredicate predicateWithFormat:@"SELF MATCHES %@", emailRegex];
    BOOL isValid = [emailTest evaluateWithObject:email];
    return isValid;
}

Answer 13

NSString *emailString = textField.text; **// storing the entered email in a string.** 
**// Regular expression to checl the email format.** 
NSString *emailReg = @"[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+//.[A-Za-z]{2,4}"; 
NSPredicate *emailTest = [NSPredicate predicateWithFormat:@"SELF MATCHES %@",emailReg]; 
if (([emailTest evaluateWithObject:emailString] != YES) || [emailStringisEqualToString:@""]) 
{ 
UIAlertView *loginalert = [[UIAlertView alloc] initWithTitle:@" Enter Email in" message:@"[email protected] format" delegate:self 
cancelButtonTitle:@"OK" otherButtonTitles:nil]; 

enter code here

[loginalert show]; 
[loginalert release]; 
} 
If email is invalid, it will remind the user with an alert box. 
Hope this might be helpful for you all.