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

¿Cuál es la forma más limpia de validar una dirección de correo electrónico que un usuario ingresa 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 a cuántas otras preguntas están vinculadas, no se puede retirar y NO DEBE cambiarse a una pregunta "moderna".

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

Recomiendo un enfoque de analizador real como MKEmailAddress .

Como solución rápida de expresiones regulares, 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];
}

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 La sección 3.4.1 es muy útil. aviso

dtext = NO-WS-CTL /; Controles sin espacios en blanco

                        % d33-90 /; El resto de los EE.UU.-ASCII
                        % d94-126; caracteres que no incluyen "[",
                                        ; "]" o "\"

Sí, eso significa que +, ', etc. son todos legítimos.

La mejor solución que he encontrado hasta ahora (y con la que terminé yendo) 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 implementado, cualquiera de las lógicas de validación de correo electrónico de expresión regular funcionará.

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í: bob.smith@foo.com o fred@bla.edu

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

Probablemente solo haya 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 caracteres (especialmente comillas y comillas), por lo que es posible que desee asumir que todas estas son cosas no válidas para hacer. Pero debe hacerlo como una decisión consciente.

Más allá de eso, haga lo que dice Paul e intente 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.

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

Dos cosas encima de mi cabeza son:

1. Validación de 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.

Esta función es simple y, sin embargo, verifica la dirección de correo electrónico más a fondo. Por ejemplo, de acuerdo con RFC2822, una dirección de correo electrónico no debe contener dos puntos seguidos, como el nombre de pila ... el nombre de pila @ dominio..com

También es importante usar anclas en expresiones regulares como se ve en esta función. Sin anclajes, la siguiente dirección de correo electrónico se considera válida: primer nombre; apellido@dominio.com (bla porque la sección apellido@dominio.com es válida, ignorando el primer nombre) al principio y (bla al final). motor de expresiones regulares para validar todo el correo electrónico.

Esta función utiliza NSPredicate, que no existe en iOS 2. Desafortunadamente, puede que no ayude al autor de la pregunta, pero con suerte ayudará a otros con versiones más recientes de iOS. Sin embargo, 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];
}

Vea validar la dirección de correo electrónico utilizando expresiones regulares en Objective-C .

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:@"abc@example.com 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. 

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

El principal inconveniente de las expresiones regulares, por supuesto, es la facilidad de mantenimiento, así que comente como nunca lo ha hecho antes. Te lo prometo, si no lo haces, desearás haberlo hecho 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 .

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

Muchos sitios web proporcionan RegExes, pero haría bien en aprenderlos y comprenderlos, así como verificar que lo que desea que haga satisfaga sus necesidades dentro del RFC oficial para formatos de dirección de correo electrónico.

Para aprender RegEx, los idiomas interpretados pueden ser un gran simplificador y un banco de pruebas. Rubular se basa 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 será desarrollar experiencia en el uso de RegEx altamente optimizado.

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

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

No debe intentar utilizar expresiones regulares para validar un correo electrónico. Con los TLD que cambian constantemente, su validador es incompleto o inexacto. En su lugar, debe aprovechar las NSDataDetectorbibliotecas de Apple que tomarán una cadena e intentarán 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 usted puede aprovechar 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 NSStringcategoría, por lo que la cadena que está 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 Stringextensión 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)"
    }
}

// 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;
}