Quais são as melhores práticas para validar endereços de e-mail no iOS 2.0

StackOverflow https://stackoverflow.com/questions/800123

Pergunta

O que é a forma mais limpa para validar um endereço de e-mail que um usuário insere no iOS 2.0?

NOTA : Esta é uma questão histórica que é específico para iOS 2.0 e devido à sua idade e quantas outras questões estão ligadas a ela não pode ser aposentado e não deve ser alterado para um "moderno "pergunta.

Foi útil?

Solução 3

A melhor solução que eu encontrei até agora (e aquele que eu acabei indo com) é adicionar RegexKitLite para o projeto que dá acesso a expressões regulares via NSString categorias.

É bastante indolor para adicionar ao projeto e uma vez no lugar, qualquer um a lógica normal de validação de e-mail expressão funcionará.

Outras dicas

A resposta para Usando uma expressão regular para validar um endereço de e-mail explica em grande detalhe que a gramática especificado no RFC 5322 é muito complicado para expressões regulares primitivos.

eu recomendo uma abordagem analisador real como MKEmailAddress .

Como solução expressões regulares rápida ver esta modificação do 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 a RFC. Quase todo mundo que pensa que sabe como analisar / limpa / validar um endereço de e-mail está errado.

http://tools.ietf.org/html/rfc2822 Seção 3.4.1 é muito útil. Aviso 

dtext           =       NO-WS-CTL /     ; Non white space controls

                        %d33-90 /       ; The rest of the US-ASCII
                        %d94-126        ;  characters not including "[",
                                        ;  "]", or "\"

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

Um bom começo é decidir o que fazer você e você não quer aceitar como um endereço de e-mail?

99% de de endereços de email parecido com este: bob.smith@foo.com ou fred@bla.edu

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

Há provavelmente apenas um punhado de e-mails válidos em todo o mundo para domínios de nível superior, e quase usos ninguém mais dessas outras personagens (especialmente citações e backticks), assim você pode querer assumir que estas são todas as coisas inválidos para Faz. Mas você deve fazê-lo como uma decisão consciente.

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

Aquele irá coincidir com praticamente endereço de e-mail de todos.

Embora o foco em expressões regulares é bom, mas este é apenas um primeiro e necessário passo. Há outros passos que também precisam ser responsáveis ??por uma estratégia de validação bom.

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

  1. validação DNS para garantir que o domínio realmente existe.

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

Desta forma, você pode pegar todos os tipos de erros de utilizador e verifique se ele é um email válido.

Esta função é o endereço simples e ainda verificações de e-mail mais profundamente. Por exemplo, de acordo com RFC2822 um endereço de e-mail não deve conter dois períodos consecutivos, como firstname..lastname @ domain..com

Também é importante o uso de âncoras em expressões regulares, como visto nesta função. Sem âncoras o seguinte endereço de e-mail é considerado válido: em primeiro lugar; nome) lastname@domain.com (blah , pois o lastname@domain.com seção é válido, ignorando em primeiro lugar; nome) no início e (blá no final Âncoras forçar o motor de expressões regulares para validar todo o e-mail

..

Esta função usa NSPredicate que não existe no iOS 2. Infelizmente, não pode ajudar o consulente, mas espero que vai ajudar os outros com as versões mais recentes do iOS. As expressões regulares nesta função ainda pode ser aplicado a RegExKitLite no iOS 2 embora. E para aqueles que utilizam iOS 4 ou posterior, estas expressões regulares podem ser implementadas com 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];
}

validar o endereço de e-mail 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.

Eu descobri que usando uma expressão regular funciona muito bem para validar um endereço de e-mail.

A principal desvantagem para expressões regulares do curso é de manutenção, por isso comentário como você nunca comentou antes. Eu prometo a você, se você não você vai desejar que você fez quando você voltar para a expressão depois de algumas semanas.

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

Desenterrar a sujeira, mas eu só tropeçou em SHEmailValidator que faz um trabalho perfeito e tem um bom interface.

Muitos sites fornecem expressões regulares, mas você faria bem para aprender e entendê-los, bem como verificar se o que você quer que ele faça atenda às suas necessidades dentro do RFC oficial para formatos de endereço de e-mail.

Para aprender RegEx, interpretado línguas pode ser um grande simplificador e testbed. Rubular é construído em Ruby, mas é uma boa maneira rápida de testar e verificar: http://www.rubular.com/

Além disso, comprar a última edição das Expressões Regulares O'Reilly livro Mastering. Você vai querer passar o tempo para entender os primeiros 3 ou 4 capítulos. Tudo depois disso será a construção de conhecimentos sobre o uso RegEx altamente otimizado.

Muitas vezes, uma série de menor, mais fácil de gerenciar expressões regulares são mais fáceis de manter e depurar.

Aqui é uma extensão da corda que valida um e-mail em 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 do resposta para: que um endereço de email é válida para iOS

Você não deve tentar usar regex para validar um e-mail. Com sempre mudando TLDs, o validador está incompleta ou imprecisa. Em vez disso, você deve alavancar bibliotecas NSDataDetector da Apple, que terá uma corda e tentar ver se existem campos conhecidos de dados (e-mails, endereços, datas, etc). SDK da Apple vai fazer o trabalho pesado de manter-se atualizado com TLDs e você pode pegar carona fora de seus esforços !! :)

Além disso, se iMessage (ou qualquer outro campo de texto) não acho que é um e-mail, você deve considerar um e-mail?

Eu coloquei essa função em uma categoria NSString, assim que a corda 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 extensão rápida 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)"
    }
}

// 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;
}
Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top