Quais são as práticas recomendadas para validar endereços de email no iOS 2.0

Qual é a maneira mais limpa de validar um endereço de e-mail inserido por um usuário no iOS 2.0?

NOTA : Esta é uma pergunta histórica que é específica para o iOS 2.0 e, devido à sua idade, e quantas outras perguntas estão vinculadas a ele, ela não pode ser retirada e NÃO DEVE ser alterada para uma pergunta "moderna".

A resposta para Usar uma expressão regular para validar um endereço de email explica detalhadamente que a gramática especificada na RFC 5322 é muito complicada para expressões regulares primitivas.

Eu recomendo uma abordagem real do analisador como o MKEmailAddress .

Como solução rápida para expressões regulares, veja esta modificação 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];
}

Leia o RFC. Quase todo mundo que pensa que sabe analisar / limpar / validar um endereço de email está errado.

http://tools.ietf.org/html/rfc2822 A seção 3.4.1 é muito útil. Aviso prévio

dtext = NO-WS-CTL /; Controles de espaço não em branco

                        % d33-90 /; O resto do US-ASCII
                        % d94-126; caracteres que não incluem "[",
                                        ; "]" ou "\"

Sim, isso significa que +, ', etc são todos legítimos.

A melhor solução que encontrei até agora (e a que acabei usando) é adicionar o RegexKitLite ao projeto que dá acesso a expressões regulares por meio das categorias NSString.

É muito simples adicionar ao projeto e, uma vez implementada, qualquer lógica de validação de email de expressão regular funcionará.

Um bom começo é decidir o que você deseja e não deseja aceitar como endereço de email?

99% dos endereços de e-mail são assim: bob.smith@foo.com ou fred@bla.edu

No entanto, é tecnicamente legal ter um endereço de email como este: f !#$%&'*+-/=?^_{|} ~ "ha!" @ Com

Provavelmente, existem apenas alguns e-mails válidos no mundo para domínios de nível superior, e quase ninguém usa a maioria desses outros caracteres (especialmente aspas e backticks); portanto, você pode assumir que tudo isso é inválido. Mas você deve fazê-lo como uma decisão consciente.

Além disso, faça o que Paulo diz e tente combinar a entrada com uma expressão regular como esta: ^ [A-Z0-9 ._% + -] + @ [A-Z0-9 .-] +. [AZ] { 2,} $

Esse corresponderá ao endereço de e-mail de todos.

Embora o foco nas expressões regulares seja bom, este é apenas um primeiro e necessário passo. Existem outras etapas que também precisam ser consideradas para uma boa estratégia de validação.

Duas coisas em cima da minha cabeça são:

1. Validação de DNS para garantir que o domínio realmente exista.

2. Após a validação do DNS, você também pode optar por fazer uma validação smtp. envie uma chamada para o servidor smtp para ver se o usuário realmente existe.

Dessa forma, você pode detectar todos os tipos de erros do usuário e garantir que seja um email válido.

Essa função é simples e ainda verifica o endereço de email mais detalhadamente. Por exemplo, de acordo com a RFC2822, um endereço de e-mail não deve conter dois períodos seguidos, como firstname..lastname @ domain..com

Também é importante usar âncoras em expressões regulares, como visto nesta função. Sem âncoras, o seguinte endereço de email é considerado válido: primeiro; nome) sobrenome@domínio.com (blá porque a seção sobrenome@domínio.com é válida, ignorando primeiro; nome) no início e (blá no final. mecanismo de expressões regulares para validar todo o email.

Essa função usa NSPredicate, que não existe no iOS 2. Infelizmente, pode não ajudar o solicitante, mas espero que ajude outras pessoas com as versões mais recentes do iOS. As expressões regulares nesta função ainda podem ser aplicadas ao RegExKitLite no iOS 2. E para aqueles que usam o iOS 4 ou posterior, essas expressões regulares podem ser implementadas com o 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 validar endereço de email usando expressão regular em 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. 

Descobri que o uso de uma expressão regular funciona muito bem para validar um endereço de email.

A principal desvantagem das expressões regulares, é claro, é a manutenção, portanto, comente como você nunca comentou antes. Eu prometo a você, se não o desejar, o fará quando voltar à expressão depois de algumas semanas.

Aqui está um link para uma boa fonte, http://www.regular-expressions.info/email.html .

Desenterrando a sujeira, mas acabei encontrando o SHEmailValidator, que faz um trabalho perfeito e tem uma interface agradável.

Muitos sites fornecem RegExes, mas é bom aprendê-los e compreendê-los, além de verificar se o que você quer fazer atende às suas necessidades na RFC oficial para formatos de endereço de email.

Para aprender RegEx, idiomas interpretados podem ser um ótimo simplificador e ambiente de teste. O Rubular é baseado no Ruby, mas é uma boa maneira rápida de testar e verificar: http://www.rubular.com/

Além disso, compre a última edição do livro O'Reilly, Mastering Regular Expressions. Você vai querer gastar tempo para entender os primeiros 3 ou 4 capítulos. Tudo o que se seguirá estará desenvolvendo conhecimentos sobre o uso RegEx altamente otimizado.

Freqüentemente, uma série de RegExes menores e mais fáceis de gerenciar são mais fáceis de manter e depurar.

Aqui está uma extensão de String que valida um email no 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 da resposta para: Verifique se um endereço de email é válido no iOS

Você não deve tentar usar o regex para validar um email. Com os TLDs sempre em mudança, seu validador é incompleto ou impreciso. Em vez disso, você deve aproveitar as NSDataDetectorbibliotecas da Apple, que receberão uma string e tentarão ver se existem campos de dados conhecidos (e-mails, endereços, datas, etc.). O SDK da Apple fará o trabalho pesado de manter-se atualizado com os TLDs e você poderá pegar carona nos esforços deles! :)

Além disso, se o iMessage (ou qualquer outro campo de texto) não achar que é um email, considere um email?

Eu coloquei essa função em uma NSStringcategoria, então a string que você está testando é 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]]);
}

ou como uma Stringextensão 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;
}