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

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

Question

Quel est le moyen le plus propre de valider une adresse électronique saisie par un utilisateur sous iOS 2.0?

REMARQUE : 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 un " moderne " question.

Était-ce utile?

La solution 3

La meilleure solution que j'ai trouvée jusqu'à présent (et celle avec laquelle j'ai fini par aller) consiste à 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, toute la logique de validation des courriers électroniques des expressions régulières fonctionnera.

Autres conseils

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

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

En tant que solution rapide pour les expressions rationnelles, consultez 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];
}

Lisez le RFC. Presque toutes les personnes qui pensent savoir comment analyser / nettoyer / valider une adresse e-mail sont incorrectes.

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

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

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

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

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

99% des adresses électroniques se présentent comme suit: bob.smith@foo.com ou fred@bla.edu

Cependant, il est techniquement légal d'avoir une adresse électronique comme celle-ci: f ! # $% & amp; '* + - / =? ^ _ {|} ~ "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 de ces autres caractères (en particulier les guillemets et les backticks). faire. Mais vous devriez le faire en prenant une décision consciente.

Au-delà de cela, 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 à l'adresse électronique de tout le monde.

Bien que l'accent soit mis sur les expressions régulières, il ne s'agit que d'une première étape 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 faire une validation smtp. envoyer un appel au serveur smtp à voir si l'utilisateur existe réellement.

De cette manière, vous pouvez intercepter toutes sortes d'erreurs utilisateur et vous assurer que le courrier électronique est valide.

Cette fonction est simple et 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) nom@domaine.com (blah car la section nom@domaine.com est valide, en ignorant first; name) au 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, mais nous espérons pouvoir aider 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 l'adresse e-mail à l'aide d'une expression régulière dans 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.

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

L’inconvénient majeur des expressions régulières est bien sûr la maintenabilité, alors commentez comme vous ne l’avez jamais fait auparavant. Je vous promets que, si vous ne le faites pas, vous souhaiteriez 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 .

J'ai creusé la poussière, mais je suis tombé sur SHEmailValidator , qui fait un travail parfait et qui a une bonne interface.

De nombreux sites Web fournissent des RegEx, 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 de messagerie.

Pour l’apprentissage de 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à, achetez la dernière édition du livre O'Reilly Mastering Regular Expressions. Vous aurez envie de passer le temps de 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 RegExes plus petits, plus faciles à gérer, sont plus faciles à gérer et à déboguer.

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}<*>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)
    }
}

Copié de la réponse à: vérifier qu'une adresse électronique est valide sur iOS

Vous ne devriez pas essayer d'utiliser regex pour valider un email. Avec les TLD en constante évolution, votre validateur est incomplet ou inexact. Utilisez plutôt les bibliothèques NSDataDetector d’Apple, qui prennent une chaîne, et essayez de voir s’il existe des champs de données connus (adresses e-mail, adresses, dates, etc.). Le SDK d’Apple se charge de rester à jour avec les TLD et vous pouvez profiter de leurs efforts !! :)

De plus, si iMessage (ou tout autre champ de texte) ne pense pas qu'il s'agisse d'un courrier électronique, devez-vous envisager un courrier électronique?

Je mets cette fonction dans une catégorie NSString , de sorte que la chaîne que vous testez est 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 comme une extension rapide 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;
}
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top