Quali sono le migliori pratiche per la convalida degli indirizzi e-mail su iOS 2.0

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

Domanda

Qual è il modo più pulito per convalidare un indirizzo email che un utente inserisce su iOS 2.0?

NOTA : si tratta di una domanda storica specifica per iOS 2.0, a causa della sua età e di quante altre domande ad essa collegate non può essere ritirata e NON DEVE essere cambiata in " moderno " domanda.

È stato utile?

Soluzione 3

La migliore soluzione che ho trovato finora (e quella con cui sono finito) è aggiungere RegexKitLite al progetto che dà accesso alle espressioni regolari tramite le categorie NSString.

È abbastanza indolore da aggiungere al progetto e una volta in atto, funzionerà una qualsiasi delle logiche di validazione e-mail delle espressioni regolari.

Altri suggerimenti

La risposta a L'uso di un'espressione regolare per convalidare un indirizzo e-mail spiega in dettaglio che la grammatica specificata in RFC 5322 è troppo complicato per le espressioni regolari primitive.

Raccomando un vero approccio al parser come MKEmailAddress .

Come soluzione per espressioni regolari veloci vedi questa modifica di 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];
}

Leggi la RFC. Quasi tutti quelli che pensano di sapere come analizzare / pulire / convalidare un indirizzo e-mail hanno torto.

http://tools.ietf.org/html/rfc2822 La sezione 3.4.1 è molto utile. Avviso 

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

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

Sì, significa +, ', ecc. sono tutti legittimi.

Un buon inizio è decidere cosa fai e non vuoi accettare come indirizzo email?

Il 99% degli indirizzi e-mail è simile al seguente: bob.smith@foo.com o fred@bla.edu

Tuttavia, è tecnicamente legale avere un indirizzo email come questo: f ! # $% & amp; '* + - / =? ^ _ {|} ~ " ha! " @ com

Probabilmente ci sono solo una manciata di e-mail valide al mondo per domini di primo livello, e quasi nessuno usa la maggior parte di quegli altri caratteri (in particolare virgolette e backtick), quindi potresti voler supporre che queste siano tutte cose non valide per fare. Ma dovresti farlo come una decisione consapevole.

Oltre a ciò, fai quello che dice Paul e cerca di far corrispondere l'input a un'espressione regolare come questa: ^ [A-Z0-9 ._% + -] + @ [A-Z0-9 .-] +. [ AZ] {2,} $

Quello corrisponderà praticamente all'indirizzo e-mail di tutti.

Mentre l'attenzione alle espressioni regolari è buona, ma questo è solo un primo e necessario passo. Ci sono altri passaggi che devono anche essere considerati per una buona strategia di validazione.

Due cose in cima alla mia testa sono:

  1. Convalida DNS per assicurarsi che il dominio esista effettivamente.

  2. Dopo la convalida DNS, puoi anche scegliere di effettuare una convalida smtp. inviare una chiamata al server smtp a vedere se l'utente esiste davvero.

In questo modo puoi rilevare tutti i tipi di errori dell'utente e assicurarti che sia un'e-mail valida.

Questa funzione è semplice e tuttavia controlla l'indirizzo e-mail in modo più approfondito. Ad esempio, secondo RFC2822, un indirizzo e-mail non deve contenere due punti consecutivi, come nome..lastname @ domain..com

È anche importante usare le ancore nelle espressioni regolari come si vede in questa funzione. Senza ancore il seguente indirizzo e-mail è considerato valido: nome; nome) cognome@dominio.com (blah perché la sezione cognome@dominio.com è valida, ignorando prima; nome) all'inizio e (blah alla fine. Le ancore impongono al motore delle espressioni regolari di convalidare l'intera e-mail.

Questa funzione utilizza NSPredicate che non esiste in iOS 2. Sfortunatamente potrebbe non aiutare chi lo richiede, ma si spera che aiuterà gli altri con le versioni più recenti di iOS. Le espressioni regolari in questa funzione possono comunque essere applicate a RegExKitLite in iOS 2. E per coloro che usano iOS 4 o versioni successive, queste espressioni regolari possono essere implementate con 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];
}

Vedi convalidare l'indirizzo e-mail usando l'espressione regolare 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.

Ho scoperto che l'uso di un'espressione regolare funziona abbastanza bene per convalidare un indirizzo email.

Il principale svantaggio delle espressioni regolari è ovviamente la manutenibilità, quindi commenta come non hai mai commentato prima. Te lo prometto, se non lo farai vorresti farlo quando tornerai all'espressione dopo alcune settimane.

Ecco un link a una buona fonte, http: //www.regular-expressions. informazioni / email.html .

Scavando lo sporco, ma mi sono appena imbattuto in SHEmailValidator che fa un lavoro perfetto e ha un bel lavoro interfaccia.

Molti siti Web forniscono RegExes, ma faresti bene a impararli e capirli, nonché a verificare che ciò che vuoi che faccia soddisfi le tue esigenze all'interno della RFC ufficiale per i formati di indirizzi e-mail.

Per l'apprendimento di RegEx, le lingue interpretate possono essere un grande semplificatore e un banco di prova. Rubular è basato su Ruby, ma è un buon modo rapido per testare e verificare: http://www.rubular.com/

Oltre a ciò, acquista l'ultima edizione del libro O'Reilly Mastering Regular Expressions. Ti consigliamo di dedicare del tempo a comprendere i primi 3 o 4 capitoli. In seguito, tutto ciò costituirà una competenza sull'utilizzo altamente ottimizzato di RegEx.

Spesso una serie di RegEx più piccoli e più facili da gestire sono più facili da gestire ed eseguire il debug.

Ecco un'estensione di String che convalida un'e-mail in 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)
    }
}

Copiato dalla risposta a: Verifica che un indirizzo email è valido su iOS

Non dovresti provare a usare regex per convalidare un'email. Con i TLD in continua evoluzione, il tuo validatore è incompleto o impreciso. Invece, dovresti sfruttare le librerie NSDataDetector di Apple che prenderanno una stringa e proveranno a vedere se ci sono campi di dati noti (e-mail, indirizzi, date, ecc.). L'SDK di Apple farà il duro lavoro per tenersi aggiornato con i TLD e si può tornare indietro dai loro sforzi !! :)

Inoltre, se iMessage (o qualsiasi altro campo di testo) non pensa che sia un'e-mail, dovresti prendere in considerazione un'e-mail?

Ho inserito questa funzione in una categoria NSString , quindi la stringa che stai 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<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]]);
}

o come rapida estensione 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;
}
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top