Jakie są najlepsze praktyki sprawdzania adresów e-mail w systemie iOS 2.0

ODPOWIEDŹ na użycie wyrażenia regularnego do walidacji adresu e-mail wyjaśnia bardzo szczegółowo, że gramatyka określona w RFC 5322 jest zbyt skomplikowana dla prymitywnych wyrażeń regularnych.

Polecam prawdziwe podejście parsera, takie jak MKEmailAddress .

Jako rozwiązanie szybkich wyrażeń regularnych patrz ta modyfikacja 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];
}

Przeczytaj RFC. Prawie każdy, kto myśli, że wie, jak analizować/czyścić / walidować adres e-mail, jest zły.

Http://tools.ietf.org/html/rfc2822 Sekcja 3.4.1 jest bardzo przydatna. Notice

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

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

Tak, oznacza to+,', itd.

Dobry początek to zdecydować, co chcesz, a nie chcesz zaakceptować jako adres e-mail?

99% adresów e-mail wygląda tak: [email protected] lub [email protected]

Jednak technicznie legalne jest posiadanie takiego adresu e-mail: f!#$%&'*+-/=?^_{|}~"ha!"@com

Prawdopodobnie na świecie jest tylko kilka ważnych wiadomości e-mail dla domen najwyższego poziomu i prawie nikt nie używa większości tych innych znaków( zwłaszcza cudzysłowów i backtików), więc możesz założyć że to wszystko są niewłaściwe rzeczy do zrobienia. Ale powinieneś to zrobić jako świadomą decyzję.

Poza tym, zrób to, co mówi Paweł i spróbuj dopasować dane wejściowe do wyrażenia regularnego, takiego jak: ^[a-z0-9._%+- ] + @[A-Z0-9.-]+.[A-Z]{2,}$

Ten będzie pasował do prawie wszystkich adresów e-mail.

Chociaż skupienie się na wyrażeniach regularnych jest dobre, ale jest to tylko pierwszy i konieczny krok. Istnieją inne kroki, które również muszą być uwzględnione w dobrej strategii walidacji.

Dwie rzeczy na głowie to:

1. Walidacja DNS, aby upewnić się, że domena rzeczywiście istnieje.

2. Po walidacji dns Możesz również wybrać walidację smtp. wyślij połączenie na serwer smtp do sprawdź, czy użytkownik rzeczywiście istnieje.

W ten sposób możesz wychwycić wszystkie rodzaje błędów użytkownika i upewnić się, że jest to prawidłowy e-mail.

Ta funkcja jest prosta, a jednak dokładniej sprawdza adres e-mail. Na przykład, zgodnie z RFC2822 adres e-mail nie może zawierać dwóch okresów z rzędu, takich jak [email protected]

Ważne jest również, aby używać kotwic w wyrażeniach regularnych, jak widać w tej funkcji. Bez anchorów następujący adres e-mail jest uważany za ważny: imię i nazwisko)[email protected] (Bla ponieważ [email protected] sekcja jest poprawna, ignorując first; name) na początku i (blah na końcu. Kotwice zmuszają silnik wyrażeń regularnych do walidacji całej wiadomości e-mail.

Ta funkcja używa NSPredicate, który nie istnieje w iOS 2. Niestety może nie pomóc asker, ale mam nadzieję, że pomoże innym z nowszymi wersjami iOS. Wyrażenia regularne w tej funkcji mogą być nadal stosowane do RegExKitLite w iOS 2 choć. A dla osób korzystających z systemu iOS 4 lub nowszego te wyrażenia regularne można zaimplementować z 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];
}

Zobacz Walidacja adresu e-mail za pomocą wyrażenia regularnego w 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:@"[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. 

Odkryłem, że użycie wyrażenia regularnego działa całkiem dobrze, aby zweryfikować adres e-mail.

Głównym minusem wyrażeń regularnych jest oczywiście konserwacja, więc komentuj tak, jak nigdy wcześniej. Obiecuję ci, jeśli tego nie zrobisz, będziesz żałował, kiedy wrócisz do wyrażenia po kilku tygodniach.

Oto link do dobrego źródła, http://www.regular-expressions.info/email.html .

Wykopałem brud, ale właśnie natknąłem się na SHEmailValidator , który wykonuje idealną pracę i ma ładny interfejs.

Wiele stron internetowych udostępnia wyrażenia regularne, ale warto je poznać i zrozumieć, a także sprawdzić, czy to, co chcesz zrobić, spełnia Twoje potrzeby w oficjalnym RFC dla formatów adresów e-mail.

Do nauki wyrażeń regularnych języki interpretowane mogą być bardzo uproszczone i testowane. Rubular jest zbudowany na Ruby, ale jest dobrym szybkim sposobem na testowanie i weryfikację: http://www.rubular.com/

Poza tym kup najnowsze wydanie książki O ' Reilly Mastering Regular Wyrażenia. Będziesz chciał poświęcić czas na zrozumienie pierwszych 3 lub 4 rozdziałów. Wszystko po tym będzie budowanie wiedzy na temat wysoce zoptymalizowanego użycia RegEx.

Często seria mniejszych, łatwiejszych do zarządzania wyrażeń regularnych jest łatwiejsza w utrzymaniu i debugowaniu.

Tutaj znajduje się rozszerzenie łańcucha, które waliduje wiadomość e-mail w języku 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)
    }
}

Skopiowane z odpowiedzi na: Sprawdź, czy adres e-mail jest ważny na iOS

Nie powinieneś używać wyrażenia regex do weryfikacji wiadomości e-mail. Przy stale zmieniających się TLD walidator jest niekompletny lub niedokładny. Zamiast tego powinieneś wykorzystać biblioteki NSDataDetector firmy Apple, które pobierają ciąg znaków i próbują sprawdzić, czy są jakieś znane pola danych (e-maile, adresy, daty itp.). SDK firmy Apple sprawi, że będziesz na bieżąco z TLD, a Ty będziesz mógł odpuścić sobie ich wysiłki!! :)

Plus, jeśli iMessage (lub jakiekolwiek inne pole tekstowe) nie uważa, że to e-mail, czy należy rozważyć e-mail?

Umieściłem tę funkcję w kategorii NSString, więc testowany ciąg znaków to 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]]);
}

Lub jako rozszerzenie 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;
}