Was sind Best Practices für die Überprüfung von E-Mail-Adressen unter iOS 2.0?

Was ist der sauberste Weg, um eine E-Mail-Adresse zu überprüfen, die ein Benutzer unter iOS 2.0 eingibt?

HINWEIS : Dies ist eine historische Frage, die spezifisch für iOS 2.0 ist. Aufgrund ihres Alters und der Anzahl der damit verbundenen anderen Fragen kann sie nicht zurückgezogen werden und darf NICHT in eine "moderne" Frage geändert werden.

Die Antwort auf Verwenden eines regulären Ausdrucks zum Überprüfen einer E-Mail-Adresse erklärt ausführlich, dass die in RFC 5322 angegebene Grammatik für primitive reguläre Ausdrücke zu kompliziert ist.

Ich empfehle einen echten Parser-Ansatz wie MKEmailAddress .

Als schnelle Lösung für reguläre Ausdrücke siehe diese Modifikation von 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];
}

Lesen Sie den RFC. Fast jeder, der glaubt zu wissen, wie man eine E-Mail-Adresse analysiert / bereinigt / validiert, ist falsch.

http://tools.ietf.org/html/rfc2822 Abschnitt 3.4.1 ist sehr nützlich. Beachten

dtext = NO-WS-CTL /; Steuerelemente ohne Leerzeichen

                        % d33-90 /; Der Rest der US-ASCII
                        % d94-126; Zeichen ohne "[",
                                        ;; "]", oder "\"

Ja, das bedeutet, dass +, 'usw. alle legitim sind.

Die beste Lösung, die ich bisher gefunden habe (und die ich letztendlich gefunden habe), ist das Hinzufügen von RegexKitLite zum Projekt, das den Zugriff auf reguläre Ausdrücke über NSString-Kategorien ermöglicht.

Es ist ziemlich einfach, das Projekt zu erweitern, und sobald es eingerichtet ist, funktioniert jede E-Mail-Validierungslogik für reguläre Ausdrücke.

Ein guter Anfang ist zu entscheiden, was Sie tun und was Sie nicht als E-Mail-Adresse akzeptieren möchten?

99% der E-Mail-Adressen sehen folgendermaßen aus: bob.smith@foo.com oder fred@bla.edu

Es ist jedoch technisch legal, eine E-Mail-Adresse wie diese zu haben: f !#$%&'*+-/=?^_{|} ~ "ha!" @ Com

Es gibt wahrscheinlich nur eine Handvoll gültiger E-Mails auf der Welt für Top-Level-Domains, und fast niemand verwendet die meisten dieser anderen Zeichen (insbesondere Anführungszeichen und Backticks). Daher sollten Sie davon ausgehen, dass dies alles ungültige Dinge sind. Aber Sie sollten dies als bewusste Entscheidung tun.

Tun Sie darüber hinaus, was Paulus sagt, und versuchen Sie, die Eingabe einem regulären Ausdruck wie diesem zuzuordnen: ^ [A-Z0-9 ._% + -] + @ [A-Z0-9 .-] +. [AZ] { 2,} $

Dieser wird so ziemlich jeder E-Mail-Adresse entsprechen.

Der Fokus auf reguläre Ausdrücke ist zwar gut, aber dies ist nur ein erster und notwendiger Schritt. Es gibt andere Schritte, die ebenfalls für eine gute Validierungsstrategie berücksichtigt werden müssen.

Zwei Dinge auf meinem Kopf sind:

1. DNS-Validierung, um sicherzustellen, dass die Domain tatsächlich vorhanden ist.

2. Nach der DNS-Validierung können Sie auch eine SMTP-Validierung durchführen. Senden Sie einen Anruf an den SMTP-Server, um festzustellen, ob der Benutzer tatsächlich vorhanden ist.

Auf diese Weise können Sie alle Arten von Benutzerfehlern abfangen und sicherstellen, dass es sich um eine gültige E-Mail handelt.

Diese Funktion ist einfach und überprüft die E-Mail-Adresse dennoch gründlicher. Beispielsweise darf eine E-Mail-Adresse gemäß RFC2822 nicht zwei Punkte hintereinander enthalten, z. B. Vorname..Nachname @ Domäne..com

Es ist auch wichtig, Anker in regulären Ausdrücken zu verwenden, wie in dieser Funktion gezeigt. Ohne Anker wird die folgende E-Mail-Adresse als gültig angesehen: Vorname; Name) Nachname@domain.com (bla, da der Abschnitt Nachname@domain.com gültig ist, wobei Vorname ignoriert wird ; Name) am Anfang und (bla am Ende. Anker erzwingen die Engine für reguläre Ausdrücke zur Validierung der gesamten E-Mail.

Diese Funktion verwendet NSPredicate, das in iOS 2 nicht vorhanden ist. Leider hilft es dem Fragesteller möglicherweise nicht, aber hoffentlich hilft es anderen mit neueren Versionen von iOS. Die regulären Ausdrücke in dieser Funktion können jedoch weiterhin auf RegExKitLite in iOS 2 angewendet werden. Und für Benutzer von iOS 4 oder höher können diese regulären Ausdrücke mit NSRegularExpression implementiert werden.

- (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];
}

Siehe Überprüfen der E-Mail-Adresse mit regulären Ausdrücken in 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. 

Ich habe festgestellt, dass die Verwendung eines regulären Ausdrucks zum Überprüfen einer E-Mail-Adresse recht gut funktioniert.

Der Hauptnachteil regulärer Ausdrücke ist natürlich die Wartbarkeit. Kommentieren Sie also, wie Sie es noch nie zuvor getan haben. Ich verspreche Ihnen, wenn Sie dies nicht tun, werden Sie es wünschen, wenn Sie nach ein paar Wochen zum Ausdruck zurückkehren.

Hier ist ein Link zu einer guten Quelle, http://www.regular-expressions.info/email.html .

Den Dreck ausgraben , aber ich bin gerade auf SHEmailValidator gestoßen, der einen perfekten Job macht und eine schöne Oberfläche hat.

Viele Websites bieten RegExes an, aber Sie sollten sie gut lernen und verstehen sowie überprüfen, ob das, was Sie möchten, Ihren Anforderungen innerhalb des offiziellen RFC für E-Mail-Adressformate entspricht.

Für das Erlernen von RegEx können interpretierte Sprachen eine große Vereinfachung und Testumgebung sein. Rubular basiert auf Ruby, ist jedoch eine gute Möglichkeit zum schnellen Testen und Überprüfen: http://www.rubular.com/

Kaufen Sie darüber hinaus die neueste Ausgabe des O'Reilly-Buches Mastering Regular Expressions. Sie sollten sich die Zeit nehmen, um die ersten 3 oder 4 Kapitel zu verstehen. Alles danach wird Fachwissen über eine hochoptimierte RegEx-Nutzung aufbauen.

Oft ist eine Reihe kleinerer, einfacher zu verwaltender RegExes einfacher zu warten und zu debuggen.

Hier ist eine Erweiterung von String, die eine E-Mail in Swift validiert.

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

Von der Antwort kopiert an: Überprüfen Sie, ob eine E-Mail-Adresse unter iOS gültig ist

Sie sollten nicht versuchen, eine E-Mail mit Regex zu validieren. Bei sich ständig ändernden TLDs ist Ihr Validator entweder unvollständig oder ungenau. Stattdessen sollten Sie die Apple- NSDataDetectorBibliotheken nutzen, die eine Zeichenfolge verwenden und versuchen, festzustellen, ob Datenfelder (E-Mails, Adressen, Daten usw.) bekannt sind. Apples SDK wird es schwer haben, mit TLDs auf dem neuesten Stand zu bleiben, und Sie können sich von ihren Bemühungen huckepack nehmen !! :) :)

Wenn iMessage (oder ein anderes Textfeld) nicht der Meinung ist, dass es sich um eine E-Mail handelt, sollten Sie eine E-Mail in Betracht ziehen.

Ich habe diese Funktion in eine NSStringKategorie eingeordnet, daher lautet die Zeichenfolge, die Sie testen 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]]);
}

oder als schnelle StringErweiterung

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;
}