ios - Come convalidare un indirizzo e-mail in swift?




13 Answers

Vorrei usare NSPredicate :

 func isValidEmail(testStr:String) -> Bool {        
    let emailRegEx = "[A-Z0-9a-z._%+-][email protected][A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"

    let emailTest = NSPredicate(format:"SELF MATCHES %@", emailRegEx)
    return emailTest.evaluate(with: testStr)
}

per le versioni di Swift precedenti alla 3.0:

 func isValidEmail(testStr:String) -> Bool {
    // print("validate calendar: \(testStr)")
    let emailRegEx = "[A-Z0-9a-z._%+-][email protected][A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"

    let emailTest = NSPredicate(format:"SELF MATCHES %@", emailRegEx)
    return emailTest.evaluate(with: testStr)
}

per le versioni di Swift precedenti alla 1.2:

 class func isValidEmail(testStr:String) -> Bool {
    println("validate calendar: \(testStr)")
    let emailRegEx = "[A-Z0-9a-z._%+-][email protected][A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"

    if let emailTest = NSPredicate(format:"SELF MATCHES %@", emailRegEx) {
        return emailTest.evaluateWithObject(testStr)
    }
    return false
}

Qualcuno sa come convalidare un indirizzo e-mail in Swift? Ho trovato questo codice:

- (BOOL) validEmail:(NSString*) emailString {

    if([emailString length]==0){
        return NO;
    }

    NSString *regExPattern = @"[A-Z0-9a-z._%+-][email protected][A-Za-z0-9.-]+\\.[A-Za-z]{2,4}";

    NSRegularExpression *regEx = [[NSRegularExpression alloc] initWithPattern:regExPattern options:NSRegularExpressionCaseInsensitive error:nil];
    NSUInteger regExMatches = [regEx numberOfMatchesInString:emailString options:0 range:NSMakeRange(0, [emailString length])];

    NSLog(@"%i", regExMatches);
    if (regExMatches == 0) {
        return NO;
    } else {
        return YES;
    }
}

ma non posso tradurlo in Swift.




Come estensione di una classe String

SWIFT 4

extension String {
    func isValidEmail() -> Bool {
        // here, `try!` will always succeed because the pattern is valid
        let regex = try! NSRegularExpression(pattern: "^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-][email protected][a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$", options: .caseInsensitive)
        return regex.firstMatch(in: self, options: [], range: NSRange(location: 0, length: count)) != nil
    }
}

uso

if "rdfsdsfsdfsd".isValidEmail() {

}



Se stai cercando una soluzione semplice e pulita per farlo, dovresti dare un'occhiata a https://github.com/nsagora/validation-components .

Contiene un predicato di convalida della posta elettronica che è facile da integrare nel codice:

let email = "[email protected]"
let rule = EmailValidationPredicate()
let isValidEmail = rule.evaluate(with: email)

Dietro il cofano utilizza RFC 5322 reg ex ( http://emailregex.com ):

let regex = "(?:[\\p{L}0-9!#$%\\&'*+/=?\\^_`{|}~-]+(?:\\.[\\p{L}0-9!#$%\\&'*+/=?\\^_`{|}" +
    "~-]+)*|\"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\" +
    "x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*\")@(?:(?:[\\p{L}0-9](?:[a-" +
    "z0-9-]*[\\p{L}0-9])?\\.)+[\\p{L}0-9](?:[\\p{L}0-9-]*[\\p{L}0-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]?|[\\p{L}0-9-]*[\\p{L}0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21" +
    "-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)\\])"



Suggerirei di usarlo come un'estensione di String:

extension String {    
    public var isEmail: Bool {
        let dataDetector = try? NSDataDetector(types: NSTextCheckingType.Link.rawValue)
        let firstMatch = dataDetector?.firstMatchInString(self, options: NSMatchingOptions.ReportCompletion, range: NSRange(location: 0, length: length))
        return (firstMatch?.range.location != NSNotFound && firstMatch?.URL?.scheme == "mailto")
    }

    public var length: Int {
        return self.characters.count
    }
}

E per usarlo:

if "[email protected]".isEmail { // true
    print("Hold the Door")
}

Fonte: https://github.com/goktugyil/EZSwiftExtensions/blob/master/Sources/StringExtensions.swift




Ecco la soluzione ragionevole:

"LA SOLUZIONE RAGIONEVOLE"

1 - evita i molti errori di regex che vedi spesso in questi suggerimenti

2 - non consente email stupide come "x @ x" che sono tecnicamente valide, ma sono completamente stupide - e il personale di supporto, ecc., Rifiuterebbe comunque in ogni caso. Se hai bisogno (per quale scopo?) Di una soluzione che permetta email stupide, usa un'altra soluzione.

3 - è estremamente comprensibile , per quanto si possa sperare

4 - È BACIO, affidabile e testato per la distruzione su app commerciali con un numero enorme di utenti

let __firstpart = "[A-Z0-9a-z]([A-Z0-9a-z._%+-]{0,30}[A-Z0-9a-z])?"
let __serverpart = "([A-Z0-9a-z]([A-Z0-9a-z-]{0,30}[A-Z0-9a-z])?\\.){1,5}"
let __emailRegex = __firstpart + "@" + __serverpart + "[A-Za-z]{2,6}"
let __emailPredicate = NSPredicate(format: "SELF MATCHES %@", __emailRegex)

extension String {
    func isEmail() -> Bool {
        return __emailPredicate.evaluate(with: self)
    }
}

extension UITextField {
    func isEmail() -> Bool {
        return self.text.isEmail
    }
}

Spiegazione:

Nella seguente descrizione, "OC" significa carattere ordinario: quindi, una lettera o una cifra.

__firstpart ... deve iniziare e finire con un OC. Per i personaggi nel mezzo puoi avere alcuni caratteri insoliti come il trattino basso, ma l'inizio e la fine devono essere OC. (Va bene avere solo un OC e basta, esempio [email protected])

__serverpart ... Hai sezioni come "blah". quale ripetizione. (Quindi, mail.city.fcu.edu tipo di cosa.) Le sezioni devono iniziare e finire con un OC, ma nel mezzo si può anche avere un trattino "-". (Se si desidera consentire ad altri caratteri insoliti in là, ad esempio sottolineatura, è sufficiente aggiungerlo prima del trattino.) È OK avere una sezione che è solo un OC. (Come in [email protected] o [email protected]) È possibile avere fino a cinque sezioni; devi averne uno Infine il TLD (.com o simili) è strettamente composto da 2 a 6 lettere.

Nota che tieni semplicemente il predicato come globale (banale in Swift), non c'è bisogno di costruirlo ogni volta.




Preferisco usare un'estensione per questo. Inoltre, questo url http://emailregex.com può aiutarti a verificare se la regex è corretta. In effetti, il sito offre diverse implementazioni per alcuni linguaggi di programmazione. Condivido la mia implementazione per Swift 3 .

extension String {
    func validateEmail() -> Bool {
        let emailRegex = "[A-Z0-9a-z._%+-][email protected][A-Za-z0-9.-]+\\.[A-Za-z]{2,6}"
        return NSPredicate(format: "SELF MATCHES %@", emailRegex).evaluate(with: self)
    }
}



Ho creato una libreria progettata per le convalide degli input e uno dei "moduli" consente di convalidare facilmente un sacco di cose ...

Ad esempio per convalidare un'e-mail:

let emailTrial = Trial.Email
let trial = emailTrial.trial()

if(trial(evidence: "[email protected]")) {
   //email is valid
}

SwiftCop è la libreria ... spero che aiuti!




Sembra funzionare anche ...

let regex = "[A-Z0-9a-z._%+-][email protected][A-Za-z0-9.-]+\\.[A-Za-z]{2,}"

func validate(email: String) -> Bool {
    let matches = email.rangeOfString(regex, options: .RegularExpressionSearch)
    if let _ = matches {
        return true
    }
    return false
}



Dato che ora ci sono così tanti nomi di dominio di primo livello strani, smetto di controllare la lunghezza del dominio in alto ...

Ecco cosa uso:

extension String {

    func isEmail() -> Bool {
        let emailRegEx = "^[a-zA-Z0-9_.+-][email protected][a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$"
        return NSPredicate(format:"SELF MATCHES %@", emailRegEx).evaluateWithObject(self)
    } 
}



@ La risposta di JeffersonBe è vicina, ma restituisce true se la stringa è "qualcosa contenente [email protected] un'email valida" che non è ciò che vogliamo. Quanto segue è un'estensione su String che funziona bene (e consente di eseguire il test per phoneNumber validi e altri rilevatori di dati per l'avvio.

/// Helper for various data detector matches.
/// Returns `true` iff the `String` matches the data detector type for the complete string.
func matchesDataDetector(type: NSTextCheckingResult.CheckingType, scheme: String? = nil) -> Bool {
    let dataDetector = try? NSDataDetector(types: type.rawValue)
    guard let firstMatch = dataDetector?.firstMatch(in: self, options: NSRegularExpression.MatchingOptions.reportCompletion, range: NSRange(location: 0, length: length)) else {
        return false
    }
    return firstMatch.range.location != NSNotFound
        // make sure the entire string is an email, not just contains an email
        && firstMatch.range.location == 0
        && firstMatch.range.length == length
        // make sure the link type matches if link scheme
        && (type != .link || scheme == nil || firstMatch.url?.scheme == scheme)
}
/// `true` iff the `String` is an email address in the proper form.
var isEmail: Bool {
    return matchesDataDetector(type: .link, scheme: "mailto")
}
/// `true` iff the `String` is a phone number in the proper form.
var isPhoneNumber: Bool {
    return matchesDataDetector(type: .phoneNumber)
}
/// number of characters in the `String` (required for above).
var length: Int {
    return self.characters.count
}



La mia unica aggiunta all'elenco delle risposte sarebbe che per Linux, NSRegularExpression non esiste, in realtà è RegularExpression

    func isEmail() -> Bool {

    let patternNormal = "[A-Z0-9a-z._%+-][email protected][A-Za-z0-9.-]+\\.[A-Za-z]{2,6}"

    #if os(Linux)
        let regex = try? RegularExpression(pattern: patternNormal, options: .caseInsensitive)
    #else
        let regex = try? NSRegularExpression(pattern: patternNormal, options: .caseInsensitive)
    #endif

    return regex?.firstMatch(in: self, options: [], range: NSMakeRange(0, self.characters.count)) != nil

Questo compila con successo sia su macOS che su Ubuntu.




//Email validation
func validateEmail(enterEmail:String) -> Bool{
    let emailFormat = "[A-Z0-9a-z._%+-][email protected][A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"
    let emailPredicate = NSPredicate(format:"SELF MATCHES %@",emailFormat)
    return emailPredicate.evaluate(with:enterEmail)
}

100% funzionante e testato




Regex perfetto come Google Email

"^[A-Z0-9a-z][a-zA-Z0-9_.-][email protected][A-Za-z0-9.-]+\\.[A-Za-z]{2,}"



Related