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

Qual é a maneira mais clara de validar um endereço de e-mail que um usuário insere no iOS 2.0?

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

A resposta para Usar uma expressão regular para validar um endereço de e-mail explica em detalhes que a gramática especificada no RFC 5322 é muito complicada para expressões regulares primitivas.

Eu recomendo uma abordagem de analisador real como o MKEmailAddress .

Como solução rápida de expressões regulares, veja 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 o RFC. Quase todo mundo que acha que sabe como analisar / limpar / validar um endereço de e-mail 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 branco

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

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

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

É bastante indolor adicionar ao projeto e uma vez no lugar, qualquer lógica de validação de email de expressão regular funcionará.

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

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 e-mail como este: f !#$%&'*+-/=?^_ {|} ~ “Ha!” @ Com

Provavelmente existem apenas alguns e-mails válidos no mundo para domínios de nível mais alto, e quase ninguém usa a maioria desses outros caracteres (especialmente citações e backticks), então você pode supor que todas essas coisas são inválidas. Mas você deve fazer isso como uma decisão consciente.

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

Aquele vai corresponder a praticamente todos os endereços de e-mail.

Enquanto o foco em expressões regulares é bom, mas este é apenas um primeiro passo necessário. Há outras etapas que também precisam ser consideradas para uma boa estratégia de validação.

Duas coisas no topo 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.

Desta forma, você pode pegar todos os tipos de erros do usuário e ter certeza de que é um email válido.

Essa function é 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 em uma linha, como firstname..lastname @ domain..com

Também é importante usar âncoras em expressões regulares, como visto nesta function. Sem âncoras o seguinte endereço de e-mail é considerado válido: primeiro; nome) lastname@domain.com (blah porque a seção lastname@domain.com é válida, ignorando primeiro; nome) no início e (blah no final. As âncoras forçam o mecanismo de expressões regulares para validar todo o email.

Esta function usa o NSPredicate, que não existe no iOS 2. Infelizmente, isso pode não ajudar o usuário, mas esperamos que ajude outras pessoas com versões mais recentes do iOS. As expressões regulares nesta function 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]+)*\\.)+[az]{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]; } 

Veja 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. 

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

A principal desvantagem das expressões regulares é a capacidade de manutenção, por isso, comente como você nunca comentou antes. Eu prometo a você, se você não quiser, 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 eu acabei de encontrar o SHEmailValidator, que faz um trabalho perfeito e tem uma interface legal.

Muitos sites da Web fornecem RegExes, mas você faria bem em aprender e entendê-los, bem como verificar se o que você quer que ele faça atende às suas necessidades dentro do RFC oficial para formatos de endereço de email.

Para aprender RegEx, as linguagens interpretadas podem ser um ótimo simplificador e testbed. Rubular é construído sobre Ruby, mas é uma boa maneira rápida de testar e verificar: http://www.rubular.com/

Além disso, compre a edição mais recente do livro da O’Reilly, Mastering Regular Expressions. Você vai querer gastar o tempo para entender os primeiros 3 ou 4 capítulos. Depois disso, tudo estará construindo conhecimento sobre o uso altamente otimizado do RegEx.

Muitas vezes, uma série de menores, mais fáceis de gerenciar RegExes são mais fáceis de manter e depurar.

Aqui está uma extensão do 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: Verificar se um endereço de e-mail é válido no iOS

Você não deve tentar usar o regex para validar um email. Com TLDs em constante mudança, seu validador está incompleto ou impreciso. Em vez disso, você deve aproveitar as bibliotecas NSDataDetector da Apple, que usarão uma string e tentarão verificar se há campos de dados conhecidos (emails, endereços, datas, etc.). O SDK da Apple fará o trabalho pesado de manter-se atualizado com os TLDs e você pode aproveitar seus esforços !! 🙂

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

Eu coloquei essa function em uma categoria NSString , 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 *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 Swift 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; }