comme String extension de classe

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.!#$%&'*+/=?^_`{|}~-]+@[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
    }
}

Utilisation

if "rdfsdsfsdfsd".isValidEmail() {

}

édition, mise à jour pour Swift 3:

func validateEmail(enteredEmail:String) -> Bool {

    let emailFormat = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,64}"
    let emailPredicate = NSPredicate(format:"SELF MATCHES %@", emailFormat)
    return emailPredicate.evaluate(with: enteredEmail)

}

réponse originale pour Swift 2:

func validateEmail(enteredEmail:String) -> Bool {

    let emailFormat = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,64}"
    let emailPredicate = NSPredicate(format:"SELF MATCHES %@", emailFormat)
    return emailPredicate.evaluateWithObject(enteredEmail)

}

ça marche très bien.

si vous cherchez une solution propre et simple pour faire cela, vous devriez jeter un oeil à https://github.com/nsagora/validation-components .

il contient un prédicat de validation d'email qui est facile à intégrer dans votre code:

let email = "test@example.com"
let rule = EmailValidationPredicate()
let isValidEmail = rule.evaluate(with: email)

derrière la hotte il utilise le 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])+)\])"

voici un fusible des deux réponses les plus votées avec le regex correct: une extension de chaîne en utilisant predicate afin que vous puissiez appeler string.isEmail

    extension String {
        var isEmail: Bool {
           let emailRegEx = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,20}"            
           let emailTest  = NSPredicate(format:"SELF MATCHES %@", emailRegEx)
           return emailTest.evaluateWithObject(self)
        }
    }

Ceci est la version mise à jour pour Swift 2.0-2.2

 var isEmail: Bool {
    do {
        let regex = try NSRegularExpression(pattern: "^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[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.firstMatchInString(self, options: NSMatchingOptions(rawValue: 0), range: NSMakeRange(0, self.characters.count)) != nil
    } catch {
        return false
    }
}

je suggère de l'utiliser comme extension de chaîne:

extension String {    
    public var isEmail: Bool {
        let dataDetector = try? NSDataDetector(types: NSTextCheckingResult.CheckingType.link.rawValue)

        let firstMatch = dataDetector?.firstMatch(in: self, options: NSRegularExpression.MatchingOptions.reportCompletion, range: NSRange(location: 0, length: length))

        return (firstMatch?.range.location != NSNotFound && firstMatch?.url?.scheme == "mailto")
    }

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

et à son utilisation:

if "hodor@gameofthrones.com".isEmail { // true
    print("Hold the Door")
}

Voici la solution raisonnable:

"THE REASONABLE SOLUTION "

utilisé et testé pendant des années dans beaucoup, beaucoup d'applications de volume énorme.

1-il évite les nombreuses très erreurs regex vous voyez souvent dans ces suggestions

2 - n'est pas permettre stupide e-mails tels que "x@x", qui sont techniquement valable, mais qui sont complètement stupides et votre personnel de soutien, etc, serait instantanément rejeter de toute façon. Si vous avez besoin d' (dans quel but?) une solution qui permet des e-mails stupides, utiliser une autre solution.

3 - il est extrêmement compréhensible , autant que peut être espéré

4 - C'est BAISER, fiable, et testé à la destruction commerciale des applications avec un nombre énorme d'utilisateurs de

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,8}"
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
    }
}

explication:

dans la description suivante," OC " signifie caractère ordinaire: so, une lettre ou un chiffre.

_ _ première partie ... doit commencer et finir avec un OC. Pour les caractères du milieu, vous pouvez avoir quelques caractères inhabituels tels que underscore, mais le début et la fin doivent être OC. (C'est normal de n'avoir qu'un seul OCAN c'est ça, exemple j@blah.com)

_ _ serverpart ... Vous avez des sections comme " bla."qui répètent. (Donc, mail.city.fcu.edu genre de chose.) Les sections doivent commencer et finir avec un OC, mais au milieu vous pouvez aussi avoir dash "-". (Si vous voulez permettre d'autres caractères inhabituels là-dedans, dites "underscore", il suffit de l'ajouter avant le tiret.) C'est normal d'avoir une section qui n'est qu'une OC. (Comme dans joe@x.com ou joe@w.campus.edu) vous pouvez avoir jusqu'à cinq sections; vous devez en avoir une. Enfin le TLD (.com ou similaire) est strictement de 2 à 8 lettres.

notez que vous gardez simplement le prédicat comme un mondial (trivial dans Swift), pas besoin de le construire à chaque fois. C'est la première chose Qu'Apple mentionne à propos de la question dans le doco.

Voici une méthode basée sur rangeOfString :

class func isValidEmail(testStr:String) -> Bool {
    let emailRegEx = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,64}"
    let range = testStr.rangeOfString(emailRegEx, options:.RegularExpressionSearch)
    let result = range != nil ? true : false
    return result
}

Remarque: mise à jour de TLD longueur.

voici le RegEx définitif pour le courrier électronique selon la RFC 5322, notez qu'il est préférable de ne pas utiliser cela parce qu'il ne vérifie que la syntaxe de base des adresses e-mail et ne vérifie pas si le domaine de premier niveau existe.

(?:[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])+)
     \])

voir Regular-Expressions.info pour plus d'informations sur les e-mails regex.

notez qu'aucune échappatoire n'est requise par un langage tel que Objectif-C ou Swift.

je préfère utiliser une extension pour ça. En outre, cette url http://emailregex.com peut vous aider à tester si regex est correcte. En fait, le site propose différentes implémentations pour certains langages de programmation. Je partage mon implémentation pour Swift 3 .

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

il y a beaucoup de bonnes réponses ici, mais beaucoup de" regex "sont incomplets et il peut arriver qu'un email comme:" nom@domaine " résulte un email VALIDE, mais ce n'est pas le cas. Voici la solution complète:

extension String {

    var isEmailValid: Bool {
        do {
            let regex = try NSRegularExpression(pattern: "(?:[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])+)\])", options: .CaseInsensitive)
            return regex.firstMatchInString(self, options: NSMatchingOptions(rawValue: 0), range: NSMakeRange(0, self.characters.count)) != nil
        } catch {
            return false
        }
    }
}

pour swift 2.1: cela fonctionne correctement avec l'email foo@bar

extension String {
    func isValidEmail() -> Bool {
        do {
            let regex = try NSRegularExpression(pattern: "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}", options: .CaseInsensitive)
            return regex.firstMatchInString(self, options: NSMatchingOptions(rawValue: 0), range: NSMakeRange(0, self.characters.count)) != nil
        } catch {
                return false
        }
    }
}

j'ai fait une bibliothèque conçue pour les validations d'entrée et l'un des "modules" vous permet de valider un tas de trucs...

par exemple pour valider un email:

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

if(trial(evidence: "test@test.com")) {
   //email is valid
}

SwiftCop est la bibliothèque... espérons que cela aide!

créer une extension simple:

extension NSRegularExpression {

    convenience init(pattern: String) {
        try! self.init(pattern: pattern, options: [])
    }
}

extension String {

    var isValidEmail: Bool {
        return isMatching(expression: NSRegularExpression(pattern: "^[A-Z0-9a-z\._%+-]+@([A-Za-z0-9-]+\.)+[A-Za-z]{2,4}$"))
    }

    //MARK: - Private

    private func isMatching(expression: NSRegularExpression) -> Bool {
        return expression.numberOfMatches(in: self, range: NSRange(location: 0, length: characters.count)) > 0
    }
}

exemple:

"b@bb.pl".isValidEmail //true
"b@bb".isValidEmail //false

vous pouvez étendre l'extension suivante à tout ce dont vous avez besoin: isValidPhoneNumber , isValidPassword etc...

semble fonctionner aussi...

let regex = "[A-Z0-9a-z._%+-]+@[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
}

C'est une nouvelle version pour "la SOLUTION raisonnable" par @Fattie, testé sur Swift 4.1 dans un nouveau fichier appelé String+Email.swift :

import Foundation

extension String {
    private static let __firstpart = "[A-Z0-9a-z]([A-Z0-9a-z._%+-]{0,30}[A-Z0-9a-z])?"
    private static let __serverpart = "([A-Z0-9a-z]([A-Z0-9a-z-]{0,30}[A-Z0-9a-z])?\.){1,5}"
    private static let __emailRegex = __firstpart + "@" + __serverpart + "[A-Za-z]{2,6}"

    public var isEmail: Bool {
        let predicate = NSPredicate(format: "SELF MATCHES %@", type(of:self).__emailRegex)
        return predicate.evaluate(with: self)
    }
}

ainsi son usage est simple:

let str = "mail@domain.com"
if str.isEmail {
    print("\(str) is a valid e-mail address")
} else {
    print("\(str) is not a valid e-mail address")
}

Je n'aime tout simplement pas ajouter un func aux objets String , Car être une adresse e-mail est inhérent à eux (ou non). Ainsi, une propriété Bool conviendrait mieux qu'une propriété func , d'après ce que j'ai compris.

comme il y a tellement de noms de domaines bizarres de premier niveau maintenant, j'arrête de vérifier la longueur du domaine de premier niveau...

voici ce que j'utilise:

extension String {

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

réponse mise à jour @Arsonik réponse à Swift 2.2, en utilisant moins de code verbeux que d'autres solutions proposées:

extension String {
    func isValidEmail() -> Bool {
        let regex = try? NSRegularExpression(pattern: "^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[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?.firstMatchInString(self, options: [], range: NSMakeRange(0, self.characters.count)) != nil
    }
}

la réponse de @JeffersonBe est proche, mais renvoie true si la chaîne est "quelque chose contenant someone@something.com un email valide" ce qui n'est pas ce que nous voulons. Ce qui suit est une extension sur la chaîne qui fonctionne bien (et permet de tester pour phoneNumber valide et d'autres détecteurs de données à démarrer.

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

et pour Swift 3 :

extension String {
    func isValidEmail() -> Bool {
        let regex = try? NSRegularExpression(pattern: "^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[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: NSMakeRange(0, self.characters.count)) != nil
    }
}

Mon seul ajout à la liste des réponses serait que pour Linux, NSRegularExpression n'existe pas, c'est en fait RegularExpression

    func isEmail() -> Bool {

    let patternNormal = "[A-Z0-9a-z._%+-]+@[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

ce compile avec succès à la fois sur macOS et Ubuntu.

Voici une extension dans Swift 3

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

il suffit de l'utiliser comme ceci:

if yourEmailString.isValidEmail() {
    //code for valid email address
} else {
    //code for not valid email address
}

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

100% de travail et d'essai

meilleure solution avec le meilleur résultat pour

Swift 4.x

 extension String {

        func validateAsEmail() -> Bool {
            let emailRegEx = "(?:[a-zA-Z0-9!#$%\&‘*+/=?\^_`{|}~-]+(?:\.[a-zA-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])+)\])"

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

j'aime créer l'extension

   extension String {

func isValidateEmail() -> Bool {
    let emailFormat = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,64}"
    let emailPredicate = NSPredicate(format:"SELF MATCHES %@", emailFormat)
    return emailPredicate.evaluate(with: self)
}

}

utilisation:

if emailid.text!.isValidateEmail() == false(){
 //do what ever you want if string is not matched.

}

j'ai amélioré la réponse @Azik. J'autorise des caractères plus spéciaux qui sont autorisés par les lignes directrices, ainsi que retourner quelques cas de bord supplémentaires comme invalides.

le groupe pense qu'autoriser ._%+- dans la partie locale n'est pas correct selon les directives. Voir @Anton Gogolev réponse sur cette question ou voir ci-dessous:

la partie locale de l'adresse e-mail peut utiliser l'un de ces ASCII caractères:

• lettres latines majuscules et minuscules A à Z et a à z ;

• chiffres 0 à 9 ;

• caractères spéciaux !#$%&'*+-/=?^_`{|}~ ;

• point . , à condition qu'il ne s'agisse pas du Premier ou du dernier caractère sauf s'il est cité, et à condition qu'il n'apparaisse pas consécutivement sauf s'il est cité (par exemple John..Doe@example.com n'est pas autorisé mais "John..Doe"@example.com est autorisé);

• espace et "(),:;<>@[\] caractères sont autorisés avec restrictions (elles ne sont permises qu'à l'intérieur d'une chaîne citée, comme décrit dans le paragraphe ci-dessous, et, en outre, une barre oblique inverse ou les guillemets doivent être précédés d'une barre oblique inversée); les commentaires sont autorisés

• avec parenthèses à l'une ou l'autre extrémité de la partie locale; p.ex. john.smith(comment)@example.com et (comment)john.smith@example.com sont tous deux équivalents à john.smith@example.com ;

le code que j'utilise ne permettra pas les caractères spéciaux restricted out of place, mais permettra beaucoup plus d'options que la majorité des réponses ici. Je préférerais une validation plus souple plutôt qu'une erreur de prudence.

if enteredText.contains("..") || enteredText.contains("@@") 
   || enteredText.hasPrefix(".") || enteredText.hasSuffix(".con"){
       return false
}

let emailFormat = "[A-Z0-9a-z.!#$%&'*+-/=?^_`{|}~]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,64}"
let emailPredicate = NSPredicate(format:"SELF MATCHES %@", emailFormat)     
return emailPredicate.evaluate(with: enteredText)

utilisation de Swift 4.

extension String {
    func isValidEmail() -> Bool {
        let regex = try? NSRegularExpression(pattern: "^(((([a-zA-Z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\x{00A0}-\x{D7FF}\x{F900}-\x{FDCF}\x{FDF0}-\x{FFEF}])+(\.([a-zA-Z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\x{00A0}-\x{D7FF}\x{F900}-\x{FDCF}\x{FDF0}-\x{FFEF}])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\x{00A0}-\x{D7FF}\x{F900}-\x{FDCF}\x{FDF0}-\x{FFEF}])|(\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\x{00A0}-\x{D7FF}\x{F900}-\x{FDCF}\x{FDF0}-\x{FFEF}]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-zA-Z]|\d|[\x{00A0}-\x{D7FF}\x{F900}-\x{FDCF}\x{FDF0}-\x{FFEF}])|(([a-zA-Z]|\d|[\x{00A0}-\x{D7FF}\x{F900}-\x{FDCF}\x{FDF0}-\x{FFEF}])([a-zA-Z]|\d|-|\.|_|~|[\x{00A0}-\x{D7FF}\x{F900}-\x{FDCF}\x{FDF0}-\x{FFEF}])*([a-zA-Z]|\d|[\x{00A0}-\x{D7FF}\x{F900}-\x{FDCF}\x{FDF0}-\x{FFEF}])))\.)+(([a-zA-Z]|[\x{00A0}-\x{D7FF}\x{F900}-\x{FDCF}\x{FDF0}-\x{FFEF}])|(([a-zA-Z]|[\x{00A0}-\x{D7FF}\x{F900}-\x{FDCF}\x{FDF0}-\x{FFEF}])([a-zA-Z]|\d|-|_|~|[\x{00A0}-\x{D7FF}\x{F900}-\x{FDCF}\x{FDF0}-\x{FFEF}])*([a-zA-Z]|[\x{00A0}-\x{D7FF}\x{F900}-\x{FDCF}\x{FDF0}-\x{FFEF}])))\.?$", options: .caseInsensitive)
        return regex?.firstMatch(in: self, options: [], range: NSMakeRange(0, self.count)) != nil
    }
    func isValidName() -> Bool{
        let regex = try? NSRegularExpression(pattern: "^[\p{L}\.]{2,30}(?: [\p{L}\.]{2,30}){0,2}$", options: .caseInsensitive)

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

et utilisé

if (textField.text?.isValidEmail())! 
    {
      // bla bla
    }
else 
    {

    }

vous pouvez trouver utile un cadre de validation de formulaire réutilisable. Il a créé des règles de champ et vous créez créer vos règles de validation personnalisées en implémentant le protocole FieldValidator.

exemple ci-dessous: import UIKit import FormValidationKit

class ViewController: UIViewController, FormValidationDelegate, FieldValidatorDelegate { var formValidator: FormValidator?

var usernameValidator : FieldValidator?
var emailValidator : FieldValidator?

@IBOutlet weak var usernameTf: UITextField!
@IBOutlet weak var emailTf: UITextField!

@IBAction func didTapButton(sender: AnyObject) {

    formValidator?.submit()
}

override func viewDidLoad() {
    super.viewDidLoad()
    //Initialize the form validator
    formValidator = FormValidator()

    //Create field validators
    //Set nil to first field validator
    usernameValidator = FieldValidator(inputValue: { () -> AnyObject in
        return self.usernameTf.text
    }, rules: [Required(validationError: ValidationError(hint: "Field is required"))], nextValidator: nil, form: formValidator!)
    usernameValidator!.delegate = self


    emailValidator = FieldValidator(inputValue: { () -> AnyObject in
        return self.emailTf.text
    }, rules: [Email(validationError: ValidationError(hint: "Proper email format"))], nextValidator: usernameValidator!, form: formValidator!)
    emailValidator!.delegate = self

    formValidator?.initialValidator = emailValidator!
    formValidator?.delegate = self
}

//per field error delegate method
func didEvaluateField(field: FieldValidator, errors: Array<String>, form: FormValidator) {
    switch field {
    case usernameValidator!:
        println("Username field error")
        break;
    case emailValidator!:
        println("Username field error")
    default:
        println("Field error")
    }
}

//form delegate methods
func didPassFormValidation(form: FormValidation) {
    println(__FUNCTION__)
}

func didFailFormValidation(form: FormValidation) {
    println(__FUNCTION__)
}

lien Github ici

ou vous pouvez avoir une extension pour le texte optionnel de UITextField:

comment utiliser:

if  emailTextField.text.isEmailValid() {
      print("email is valid")
}else{
      print("wrong email address")
}

extension:

extension Optional where Wrapped == String {
    func isEmailValid() -> Bool{
        guard let email = self else { return false }
        let emailPattern = "[A-Za-z-0-9.-_]+@[A-Za-z0-9]+\.[A-Za-z]{2,3}"
        do{
            let regex = try NSRegularExpression(pattern: emailPattern, options: .caseInsensitive)
            let foundPatters = regex.numberOfMatches(in: email, options: .anchored, range: NSRange(location: 0, length: email.count))
            if foundPatters > 0 {
                return true
            }
        }catch{
            //error
        }
        return false
    }
}

Parfait Regex comme Google Mail

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