web-dev-qa-db-fra.com

Comment valider une adresse mail dans swift?

Est-ce que quelqu'un sait comment valider une adresse mail dans Swift? J'ai trouvé ce code:

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

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

    NSString *regExPattern = @"[A-Z0-9a-z._%+-]+@[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;
    }
}

mais je ne peux pas le traduire en Swift.

iosvalidationemailswift
290
Giorgio Nocera

Je voudrais utiliser NSPredicate:

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

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

pour les versions de Swift antérieures à 3.0:

 func isValidEmail(emailStr:String) -> Bool {

    let emailRegEx = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"

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

pour les versions de Swift antérieures à 1.2:

 class func isValidEmail(emailStr:String) -> Bool {

    let emailRegEx = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"

    if let emailPred = NSPredicate(format:"SELF MATCHES %@", emailRegEx) {
        return emailPred.evaluateWithObject(emailStr)
    }
    return false
}
701
Maxim Shoustin

Edition, 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 fonctionne bien.

104
Azik Abdullah

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

Usage

if "rdfsdsfsdfsd".isValidEmail() {

}
102
Arsonik

Si vous recherchez une solution simple et propre à cet égard, vous devriez jeter un œil à https://github.com/nsagora/validation-components .

Il contient un prédicat de validation de messagerie qui s'intègre facilement dans votre code:

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

Derrière le capot, 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])+)\\])"
46
alexcristea

Voici la solution raisonnable:

"LA SOLUTION RAISONNABLE"

Utilisé et testé pendant des années dans de nombreuses applications à volume énorme.

1 - il évite les nombreuses terribles erreurs de regex vous voyez souvent dans ces suggestions

2 - cela ne fait PAS autorise les courriels stupides tels que "x @ x" qui sont techniquement valables, mais qui sont complètement ridicules - et votre personnel de soutien les refuserait de toute façon. Si vous avez besoin d’une solution qui permette des courriels stupides, utilisez une autre solution.

3 - le code est extrêmement compréhensible

4 - Il est KISS, fiable, et () testé pour la destruction sur des applications commerciales avec un nombre énorme d'utilisateurs 

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 suite de la description, "OC" signifie caractère ordinaire - une lettre ou un chiffre.

__firstpart ... doit commencer et se terminer par un OC. Pour les caractères du milieu, vous pouvez avoir quelques caractères inhabituels, tels que le soulignement, mais le début et la fin doivent être OC. (Cependant - remarquez les crochets - il n'y a pas de problème avec un seul OC, par exemple: [email protected])

__serverpart ... Vous avez des sections comme "blah". qui répète. (Donc, type mail.city.fcu.edu.) Les sections doivent commencer et se terminer par un OC, mais au milieu, vous pouvez aussi avoir un tiret "-". (Si vous souhaitez autoriser d'autres caractères inhabituels, par exemple, soulignez, ajoutez-les avant le tiret.) Il est correct d'avoir une section composée d'un seul OC. (Comme dans [email protected]) Vous pouvez avoir jusqu'à cinq sections; vous devez en avoir un. Enfin, le TLD (tel que .com) est strictement compris entre 2 et 8.

IMPORTANT!

Vous devez conserver le prédicat en tant que global, ne le construisez pas à chaque fois.

Notez que c’est la première chose que Apple mentionne à propos du problème dans la documentation.

C'est très surprenant de voir des suggestions qui ne cachent pas le prédicat.

26
Fattie

Voici un fusible des deux réponses les plus votées avec l'expression rationnelle correcte: une extension de chaîne utilisant un prédicat 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)
        }
    }
25
Nicolas Manzini

Je suggérerais de l'utiliser comme une extension de String:

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 pour l'utiliser:

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

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
    }
}
15
Joel García Verástica

Il y a beaucoup de bonnes réponses ici, mais beaucoup de "regex" sont incomplètes et il peut arriver qu'un email tel que: "name @ domain" soit 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
        }
    }
}
8
Andrea.Ferrando

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: longueur du TLD mise à jour.

Voici le RegEx définitif pour le courrier électronique, conformément à la RFC 5322. Notez que cette option est mieux utilisée car elle vérifie uniquement la syntaxe de base des adresses électroniques 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 des informations plus complètes sur les RegEx par courrier électronique.

Notez qu’il n’est pas nécessaire de s’échapper conformément à un langage tel que Objective-C ou Swift.

8
zaph

Je préfère utiliser une extension pour cela. En outre, cette URL http://emailregex.com peut vous aider à vérifier si l'expression rationnelle 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)
    }
}
7
Marlon Ruiz

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
        }
    }
}
6
lee5783

Utilisation de Swift 4.2

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 
    {

    }
5
ikbal

Le plus simple dans Swift 5

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

Exemple

"[email protected]".isValidEmail

retourne ...

true
4
Ken Mueller

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:

"[email protected]".isValidEmail //true
"b@bb".isValidEmail //false

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

3
Bartłomiej Semańczyk

Voici une nouvelle version de "LA SOLUTION RAISONNABLE" par @Fattie, testée sur Swift 4.1 dans un nouveau fichier nommé 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)
    }
}

Donc, son utilisation est simple:

let str = "[email protected]"
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 une func aux objets String, car être une adresse électronique leur est inhérente (ou non). Donc, une propriété Bool conviendrait mieux qu'un func, à ma connaissance.

3
Alejandro Iván

Dans Swift 4.2 et Xcode 10.1

//Email validation
func isValidEmail(email: String) -> Bool {
    let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,4}"
    var valid = NSPredicate(format: "SELF MATCHES %@", emailRegex).evaluate(with: email)
    if valid {
        valid = !email.contains("Invalid email id")
    }
    return valid
}

//Use like this....
let emailTrimmedString = emailTF.text?.trimmingCharacters(in: .whitespaces)
if isValidEmail(email: emailTrimmedString!) == false {
   SharedClass.sharedInstance.alert(view: self, title: "", message: "Please enter valid email")
}

Si vous souhaitez utiliser SharedClass.

//This is SharedClass
import UIKit
class SharedClass: NSObject {

static let sharedInstance = SharedClass()

//Email validation
func isValidEmail(email: String) -> Bool {
    let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,4}"
    var valid = NSPredicate(format: "SELF MATCHES %@", emailRegex).evaluate(with: email)
    if valid {
        valid = !email.contains("Invalid email id")
    }
    return valid
}

private override init() {

}
}

Et appelez fonction comme ça ....

if SharedClass.sharedInstance. isValidEmail(email: emailTrimmedString!) == false {
   SharedClass.sharedInstance.alert(view: self, title: "", message: "Please enter correct email")
   //Your code here
} else {
   //Code here
}
2
iOS

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

Par exemple pour valider un email:

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

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

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

2
Andres

Swift 5 Email Validator - Expression rationnelle

Ce type d'implémentation possède des fonctionnalités que vous pouvez utiliser de manière très simple, telles que l'extension de chaîne, une validation excellente et une vérification complète de la RFC 2822.

Étape 1) Fichier -> Nouveau -> Fichier ... -> Swift Fichier et copie ce code:

import Foundation

extension String {

    // Checks if the `String` is a valid email address.
    func isValidEmailAddress() -> 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)
    }
}

Étape 2) Utilisation du validateur de courrier électronique comme extesion de chaîne:

@IBAction func sendEmail(_ sender: Any) {
    if let textFieldText = emailTextField.text, textFieldText.isValidEmailAddress() {
        // APICall or present next desired view controller
    } else {
        // Present an alert to tell user that is invalid email
    }
}

Exemples:

Source: lien GitHub

1
Doca

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)
        }
    }
1
Abdelahad Darwish

Swift 5

 func isValidEmailAddress(emailAddressString: String) -> Bool {

 var returnValue = true
 let emailRegEx = "[A-Z0-9a-z.-_]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,3}"

 do {
        let regex = try NSRegularExpression(pattern: emailRegEx)
        let nsString = emailAddressString as NSString
        let results = regex.matches(in: emailAddressString, range: NSRange(location: 0, length: nsString.length))

        if results.count == 0
        {
            returnValue = false
        }

    } catch let error as NSError {
        print("invalid regex: \(error.localizedDescription)")
        returnValue = false
    }

    return  returnValue
}

Ensuite:

let validEmail = isValidEmailAddress(emailAddressString: "[email protected]")
print(validEmail)
0
Arafin Russell

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 ça:

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

J'ai amélioré la réponse de @Azik. J'autorise davantage de caractères spéciaux autorisés par les directives, ainsi que de renvoyer quelques cas Edge supplémentaires comme non valides.

Le groupe pense que continuer ici pour autoriser uniquement ._%+- dans la partie locale n’est pas correct selon les directives. Voir la réponse de @Anton Gogolev sur this question ou voir ci-dessous:

La partie locale de l'adresse e-mail peut utiliser n'importe lequel de ces caractères ASCII:

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

  • chiffres 0 à 9;

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

  • point ., à condition que ce ne soit ni le premier ni le dernier caractère, sauf entre guillemets, et qu'il n'apparaisse pas consécutivement à moins qu'il ne soit entre guillemets (par exemple, [email protected] n'est pas autorisé mais "John..Doe"@example.com est autorisé) ;

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

  • avec des parenthèses aux deux extrémités de la partie locale; par exemple. john.smith(comment)@example.com et (comment)[email protected] sont tous deux équivalents à [email protected];

Le code que j'utilise n'autorisera pas les caractères spéciaux restreints, mais offrira beaucoup plus d'options que la majorité des réponses fournies ici. Je préférerais une validation plus détendue à 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)
0
JavaBeast

Puisqu'il y a tellement de noms de domaine de premier niveau étranges maintenant, je cesse de vérifier la longueur du domaine supérieur ...

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)
    } 
}
0
snowmen10
//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% en état de marche et testé

0
Mr.Javed Multani

Semble travailler 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
}
0
Logicopolis

J'aime créer une 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)
}

}

usage:

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

}
0
siva kumar

Et pour Swift:

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
    }
}
0
Danut Pralea

Réponse mise à jour @Arsonik answer to Swift 2.2, utilisant un code moins commenté 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
    }
}
0
Matias Seijas

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

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

0
Andrei Popa

Pour ceux qui cherchent encore une réponse à cette question, veuillez consulter le cadre suivant.

ATGValidator

Il s’agit d’un cadre de validation basé sur des règles, qui gère la plupart des validations hors de la boîte. Et en plus, il a form validator qui supporte la validation de plusieurs champs de texte en même temps.

Pour valider une chaîne de courrier électronique, utilisez ce qui suit:

"[email protected]".satisfyAll(rules: [StringRegexRule.email]).status

Si vous souhaitez valider un email de textfield, essayez ci-dessous le code;

textfield.validationRules = [StringRegexRule.email]
textfield.validationHandler = { result in
    // This block will be executed with relevant result whenever validation is done.
    print(result.status, result.errors)
}
// Below line is to manually trigger validation.
textfield.validateTextField()

Si vous souhaitez le valider lors de la saisie dans un champ de texte ou lorsque le focus est modifié sur un autre champ, ajoutez l'une des lignes suivantes;

textfield.validateOnInputChange(true)
// or
textfield.validateOnFocusLoss(true)

Veuillez vérifier le fichier lisez-moi à la page lien pour plus de cas d'utilisation.

0
Suran

La réponse de @ JeffersonBe est proche, mais renvoie true si la chaîne est "quelque chose contenant quelqu'[email protected] un e-mail valide", ce qui n'est pas ce que nous voulons. Ce qui suit est une extension sur String qui fonctionne bien (et permet de tester le numéro de téléphone 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
}
0
Gujamin