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

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 otras preguntas vinculadas a ella, no puede retirarse y NO DEBE cambiarse a " moderno " pregunta.

Answer 1

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

Es bastante sencillo agregarlo al proyecto y una vez implementado, funcionará cualquiera de las lógicas de validación de correo electrónico de expresiones regulares.

Answer 2

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 complicado 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];
}

Answer 3

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 /     ; 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 legítimos.

Answer 4

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

El 99% de las direcciones de correo electrónico tienen este aspecto: bob.smith@foo.com o fred@bla.edu

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

Probablemente hay 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 caracteres (especialmente las comillas y las comillas invertidas), por lo que es posible que desee asumir que estas son cosas no válidas para hacer. Pero debes 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.

Answer 5

Si bien el enfoque en las expresiones regulares es bueno, este es solo un primer paso necesario. Hay otros pasos que también deben considerarse 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 existe.

2. Después de la validación de dns, también puede elegir hacer una validación de smtp. enviar una llamada al servidor smtp a ver si el usuario realmente existe.

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

Answer 6

Esta función es simple y aún así revisa 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 primer nombre ... nombre@dominio.com.

También es importante usar anclas en expresiones regulares como se ve en esta función. Sin los anclajes, la siguiente dirección de correo electrónico se considera válida: primero; nombre) lastname@domain.com (blah porque la sección lastname@domain.com es válida, ignorando first; name) al principio y (blah al final. Los anclajes obligan al motor de expresiones regulares a validar todo el correo electrónico.

Esta función utiliza NSPredicate, que no existe en iOS 2. Lamentablemente, puede que no ayude al que la pregunta, pero esperamos que ayude 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];
}

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

Answer 7

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. 

Answer 8

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 es la capacidad de mantenimiento, así que comente como nunca lo ha comentado antes. Te lo prometo, si no lo deseas, desearás hacerlo cuando regreses 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 9

Desenterrando la suciedad, pero me topé con SHEmailValidator que hace un trabajo perfecto y tiene un buen interfaz.

Answer 10

Muchos sitios web proporcionan RegExes, pero le convendría aprenderlos y comprenderlos, así como verificar que lo que desea que cumpla con sus necesidades dentro del RFC oficial para formatos de direcciones 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. Usted querrá pasar el tiempo para entender los primeros 3 o 4 capítulos. Todo lo que se haga después de eso se desarrollará la 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.

Answer 11

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}<*>quot;
        let laxString = "^.+@([A-Za-z0-9-]+\\.)+[A-Za-z]{2}[A-Za-z]*<*>quot;
        let emailRegex = stricterFilter ? stricterFilterString : laxString
        let emailTest = NSPredicate(format: "SELF MATCHES %@", emailRegex)
        return emailTest.evaluate(with: self)
    }
}

Copiado de la respuesta a: Compruebe que una dirección de correo electrónico es válido en iOS

Answer 12

No debe intentar utilizar expresiones regulares para validar un correo electrónico. Con TLD siempre cambiantes, su validador está incompleto o es inexacto. En su lugar, debe aprovechar las bibliotecas NSDataDetector 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 puedes realizar estos 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?

Pongo 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 rápida extensión de String

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 13

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