web-dev-qa-db-fra.com

Quelles sont les meilleures pratiques pour valider les adresses électroniques sur iOS 2.0

Quel est le moyen le plus propre de valider une adresse e-mail qu'un utilisateur entre sous iOS 2.0?

NOTE: Il s'agit d'une question historique spécifique à iOS 2.0. En raison de son âge et du nombre de questions qui y sont liées, il ne peut pas être retiré et NE DOIT PAS être remplacé par une question "moderne".

cocoa-touchemail-validationiphone-sdk-2
167
Marcus S. Zarra

La meilleure solution que j'ai trouvée jusqu'à présent (et celle avec laquelle j'ai fini par aller) est d'ajouter RegexKitLite au projet qui donne accès aux expressions régulières via les catégories NSString.

Il est très aisé d’ajouter au projet et une fois en place, n’importe quelle logique de validation de courrier électronique d’expression régulière fonctionnera.

17
Marcus S. Zarra

La réponse à Utiliser une expression régulière pour valider une adresse électronique explique en détail que la grammaire spécifiée dans la RFC 5322 est trop compliquée pour les expressions régulières primitives.

Je recommande une approche d'analyse réelle telle que MKEmailAddress .

Comme solution rapide d'expressions régulières, voir cette modification 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];
}
354
catlan

Lire le RFC. Presque tout le monde qui pense savoir comment analyser/nettoyer/valider une adresse email est faux.

http://tools.ietf.org/html/rfc2822 La section 3.4.1 est très utile. Remarquer 

 dtext = NO-WS-CTL /; Contrôles d'espaces non blancs 

 % d33-90 /; Le reste de l'US-ASCII 
 % d94-126; caractères ne comprenant pas "[", 
 ; "]", ou "\"

Oui, cela signifie que +, ', etc. sont tous légitimes. 

20
Trey

Un bon début consiste à décider de ce que vous voulez et ne voulez pas accepter comme adresse électronique.

99% des adresses électroniques ressemblent à ceci: [email protected] ou [email protected]

Cependant, il est techniquement légal d'avoir une adresse électronique comme celle-ci: f!#$%&'*+-/=?^_ {|} ~ "ha!" @ Com

Il n'y a probablement qu'une poignée de courriels valides dans le monde pour les domaines de premier niveau, et presque personne n'utilise la plupart des autres caractères (en particulier les guillemets et les backticks). Vous pouvez donc supposer que ce sont des tâches non valides. Mais vous devriez le faire comme une décision consciente.

Au-delà, faites ce que Paul dit et essayez de faire correspondre l'entrée à une expression régulière comme celle-ci: ^ [A-Z0-9 ._% + -] + @ [A-Z0-9 .-] +. [AZ] { 2,} $

Celui-ci correspondra à peu près à l'adresse électronique de tout le monde.

10
Brandon Yarbrough

Cette fonction est simple et pourtant vérifie l’adresse électronique de manière plus approfondie. Par exemple, conformément à la norme RFC2822, une adresse électronique ne doit pas contenir deux points à la suite, par exemple prénom..nom @ domaine..com

Il est également important d'utiliser des ancres dans les expressions régulières, comme indiqué dans cette fonction. Sans ancres, l'adresse e-mail suivante est considérée comme valide: prénom; nom) [email protected] (blah car la section [email protected] est valide et ignore prénom; nom) à le début et (blah à la fin. Les ancres forcent le moteur des expressions régulières à valider l'intégralité de l'e-mail.

Cette fonction utilise NSPredicate qui n’existe pas dans iOS 2. Malheureusement, elle n’est peut-être pas utile au demandeur, mais nous espérons que cela aidera les autres utilisateurs de versions plus récentes d’iOS. Les expressions régulières de cette fonction peuvent néanmoins être appliquées à RegExKitLite dans iOS 2. Et pour ceux qui utilisent iOS 4 ou une version ultérieure, ces expressions régulières peuvent être implémentées avec 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];
}

Voir valider une adresse email en utilisant une expression régulière dans Objective-C .

7
Geek

Bien que l'accent soit mis sur les expressions régulières, mais il ne s'agit que d'un premier pas nécessaire. Il existe également d’autres étapes à prendre en compte pour une bonne stratégie de validation.

Deux choses sur ma tête sont:

  1. Validation DNS pour vous assurer que le domaine existe réellement.

  2. Après la validation du DNS, vous pouvez également choisir de procéder à une validation smtp . Envoyer un appel au serveur smtp pour voir si l'utilisateur existe réellement.

De cette façon, vous pouvez détecter toutes sortes d'erreurs utilisateur et vous assurer que le courrier électronique est valide.

7
Srikar Doddi
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:@"[email protected] 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.
6
hirak

J'ai constaté que l'utilisation d'une expression régulière fonctionne assez bien pour valider une adresse électronique. 

La facilité de maintenance est l’inconvénient majeur des expressions régulières, aussi, commentez comme vous ne l’avez jamais fait auparavant. Je vous promets que, si vous ne le faites pas, vous souhaiterez l'avoir fait lorsque vous revenez à l'expression après quelques semaines.

Voici un lien vers une bonne source, http://www.regular-expressions.info/email.html .

4
Paul Redman

Creuser la saleté, mais je viens de tomber sur SHEmailValidator qui fait un travail parfait et possède une interface agréable.

3
Cyrille

De nombreux sites Web fournissent des RegExes mais vous feriez bien de les apprendre et de les comprendre, ainsi que de vérifier que ce que vous voulez faire répond à vos besoins dans le RFC officiel pour les formats d'adresse électronique.

Pour apprendre RegEx, les langages interprétés peuvent être un grand simplificateur et un banc d'essai . Rubular est construit sur Ruby, mais constitue un bon moyen rapide de tester et de vérifier: http://www.rubular.com/

Au-delà de cela, achetez la dernière édition du livre O'Reilly Mastering Regular Expressions . Vous aurez envie de passer du temps à comprendre les 3 ou 4 premiers chapitres. Après cela, nous développerons notre expertise sur une utilisation hautement optimisée de RegEx.

Souvent, une série de RegEx plus petits et plus faciles à gérer sont plus faciles à gérer et à déboguer.

1
user656483

Voici une extension de String qui valide un email dans 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)
    }
}

Copié de la réponse à: Vérifier qu'une adresse e-mail est valide sur iOS

0
grez