it-swarm.com.de

Wie validiere ich eine E-Mail-Adresse in kürzester Zeit?

Weiß jemand, wie man eine E-Mail-Adresse in Swift überprüft? Ich habe diesen Code gefunden:

- (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;
    }
}

aber ich kann es nicht auf Swift übersetzen.

290
Giorgio Nocera

Ich würde NSPredicate verwenden:

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

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

für Versionen von Swift vor 3.0:

 func isValidEmail(emailStr:String) -> Bool {

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

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

für Versionen von Swift vor 1.2:

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

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

Bearbeitung, aktualisiert für Swift 3:

func validateEmail(enteredEmail: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: enteredEmail)

}

Ursprüngliche Antwort für Swift 2:

func validateEmail(enteredEmail: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.evaluateWithObject(enteredEmail)

}

Es funktioniert gut.

104
Azik Abdullah

Als String Klassenerweiterung

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

Verwendungszweck

if "rdfsdsfsdfsd".isValidEmail() {

}
102
Arsonik

Wenn Sie eine saubere und einfache Lösung dafür suchen, sollten Sie sich https://github.com/nsagora/validation-components ansehen.

Es enthält ein Prädikat für die E-Mail-Validierung, das sich leicht in Ihren Code integrieren lässt:

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

Hinter der Motorhaube wird der RFC 5322 reg ex ( http://emailregex.com ) verwendet:

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

Hier ist die vernünftige Lösung:

"DIE ANGEMESSENE LÖSUNG"

Seit Jahren in vielen großen Volumen-Apps verwendet und getestet.

1 - es vermeidet die vielen schrecklichen Regex-Fehler , die Sie oft in diesen Vorschlägen sehen

2 - es erlaubt NICHT blöde E-Mails wie "x @ x", die technisch gültig, aber völlig albern sind - und Ihre Support-Mitarbeiter würden sie sowieso sofort ablehnen. Wenn Sie eine Lösung benötigen, die dumme E-Mails zulässt, verwenden Sie eine andere Lösung.

3 - der Code ist extrem verständlich

4 - Es ist KISS, zuverlässig und auf kommerziellen Apps mit einer enormen Anzahl von Benutzern bis zur Zerstörung getestet ​​

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()
    }
}

Erläuterung:

In der folgenden Beschreibung bedeutet "OC" ein gewöhnliches Zeichen - ein Buchstabe oder eine Ziffer.

__firstpart ... muss mit einem OC beginnen und enden. Für die Zeichen in der Mitte können Sie einige ungewöhnliche Zeichen wie einen Unterstrich verwenden, aber Anfang und Ende müssen OK sein. (Beachten Sie jedoch die Klammern - es ist in Ordnung, nur ein OK zu haben und das wars zum Beispiel: [email protected])

__serverpart ... Sie haben Abschnitte wie "bla". welche wiederholen. (Also mail.city.fcu.edu) Die Abschnitte müssen mit einem OK beginnen und enden, aber in der Mitte kann auch ein Bindestrich "-" stehen. (Wenn Sie andere ungewöhnliche Zeichen zulassen möchten, sagen Sie "Unterstrich", fügen Sie sie einfach vor dem Bindestrich hinzu.) Es ist in Ordnung, einen Abschnitt zu haben, der nur ein OK enthält. (Wie in [email protected]) Sie können bis zu fünf Abschnitte haben; du musst eins haben. Schließlich ist die TLD (wie .com) streng 2 bis 8 groß.


WICHTIG!

Sie müssen das Prädikat als globales Prädikat beibehalten und nicht jedes Mal neu erstellen.

Beachten Sie, dass dies das erste ist, was Apple über das Problem in den Dokumenten erwähnt

Es ist sehr überraschend, wenn Sie Vorschläge sehen, die das Prädikat nicht zwischenspeichern.

26
Fattie

Hier ist eine Zusammenfassung der beiden am häufigsten gewählten Antworten mit dem richtigen regulären Ausdruck: eine String-Erweiterung mit Prädikat, mit der Sie string.isEmail aufrufen können

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

Ich würde vorschlagen, es als Erweiterung von String zu verwenden:

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

Und um es zu benutzen:

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

Dies ist die aktualisierte Version für Swift 2.0 - 2.2

 var isEmail: Bool {
    do {
        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.firstMatchInString(self, options: NSMatchingOptions(rawValue: 0), range: NSMakeRange(0, self.characters.count)) != nil
    } catch {
        return false
    }
}

Hier gibt es viele richtige Antworten, aber viele der "regulären Ausdrücke" sind unvollständig und es kann vorkommen, dass eine E-Mail wie "name @ domain" eine gültige E-Mail ergibt, dies ist jedoch nicht der Fall. Hier die Komplettlösung:

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

Hier ist eine Methode, die auf rangeOfString basiert:

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

Hinweis: Die TLD-Länge wurde aktualisiert.

Hier ist die definitive RegEx für E-Mails gemäß RFC 5322, beachten Sie, dass dies am besten nicht verwendet wird, da nur die grundlegende Syntax von E-Mail-Adressen überprüft wird und nicht überprüft wird, ob die Top-Level-Domain vorhanden ist.

 (?: [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] (& agr ;: [a-z0-9 -] * [a-z0-9])? \.) + [a-z0-9] (& agr ;: [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]) +) 
 \]) 

Weitere Informationen zu E-Mail-RegExs finden Sie unter Regular-Expressions.info .

Beachten Sie, dass für Sprachen wie Objective-C oder Swift kein Escapezeichen erforderlich ist.

8
zaph

Ich bevorzuge dafür eine Erweiterung. Außerdem kann diese URL http://emailregex.com Ihnen helfen, zu testen, ob Regex korrekt ist. Tatsächlich bietet die Site verschiedene Implementierungen für einige Programmiersprachen an. Ich teile meine Implementierung für 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)
    }
}
7
Marlon Ruiz

Für Swift 2.1: Dies funktioniert korrekt mit E-Mail foo @ bar

extension String {
    func isValidEmail() -> Bool {
        do {
            let regex = try NSRegularExpression(pattern: "[A-Z0-9a-z._%+-][email protected][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

Verwendung von 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
    } }

Und benutzt

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

    }
5
ikbal

Einfachster Weg in Swift 5

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

Beispiel

"[email protected]".isValidEmail

gibt zurück ...

true
4
Ken Mueller

Erstellen Sie eine einfache Erweiterung:

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\\._%+-][email protected]([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
    }
}

Beispiel:

"[email protected]".isValidEmail //true
"[email protected]".isValidEmail //false

Sie können die folgende Erweiterung auf alles erweitern, was Sie benötigen: isValidPhoneNumber, isValidPassword etc ...

Dies ist eine neue Version für "THE REASONABLE SOLUTION" von @Fattie, getestet auf Swift 4.1 in einer neuen Datei namens 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)
    }
}

So ist seine Verwendung einfach:

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")
}

Ich mag es einfach nicht, func zu den String Objekten hinzuzufügen, da ihnen eine E-Mail-Adresse innewohnt (oder nicht). So würde eine Bool -Eigenschaft meines Wissens besser passen als eine func.

3
Alejandro Iván

In Swift 4.2 und Xcode 10.1

//Email validation
func isValidEmail(email: String) -> Bool {
    let emailRegex = "[A-Z0-9a-z._%+-][email protected][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")
}

Wenn Sie SharedClass verwenden möchten.

//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._%+-][email protected][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() {

}
}

Und Funktion wie folgt aufrufen ....

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

Ich habe eine Bibliothek für Eingabevalidierungen erstellt und eines der "Module" ermöglicht Ihnen die einfache Validierung einer Reihe von Dingen ...

Zum Beispiel, um eine E-Mail zu validieren:

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

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

SwiftCop ist die Bibliothek ... hoffe es hilft!

2
Andres

Swift 5 Email Validator - Regulärer Ausdruck

Diese Art der Implementierung verfügt über Funktionen, die Sie auf sehr einfache Weise als Zeichenfolgenerweiterung, hervorragende Validierung und vollständige Verifizierung von RFC 2822 verwenden können.

Schritt 1) ​​Datei -> Neu -> Datei ... -> Swift Feile und kopiere diesen 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)
    }
}

Schritt 2) Verwendung des E-Mail-Validators als String-Erweiterung:

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

Beispiele:

Quelle: GitHub-Link

1
Doca

Beste Lösung mit bestem Ergebnis für

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

Swift 5

 func isValidEmailAddress(emailAddressString: String) -> Bool {

 var returnValue = true
 let emailRegEx = "[A-Z0-9a-z.-_][email protected][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
}

Dann:

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

Hier ist eine Erweiterung in Swift 3

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

Benutze es einfach so:

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

Ich habe @Azik Antwort verbessert. Ich erlaube mehr Sonderzeichen, die nach Richtlinien zulässig sind, und gebe einige zusätzliche Edge-Fälle als ungültig zurück.

Die Gruppe denkt, hier nur ._%+- im lokalen Teil zuzulassen, ist laut Richtlinien nicht korrekt. Siehe @ Anton Gogolev Antwort auf diese Frage oder siehe unten:

Der lokale Teil der E-Mail-Adresse kann folgende ASCII Zeichen enthalten:

  • lateinische Groß- und Kleinbuchstaben A bis Z und a bis z;

  • ziffern 0 bis 9;

  • sonderzeichen !#$%&'*+-/=?^_`{|}~;

  • punkt ., sofern es nicht das erste oder letzte Zeichen ist, sofern es nicht in Anführungszeichen gesetzt ist, und sofern es nicht in Anführungszeichen gesetzt ist (z. B. [email protected] ist nicht zulässig, aber "John..Doe"@example.com ist zulässig) ;

  • leerzeichen und "(),:;<>@[\] -Zeichen sind mit Einschränkungen zulässig (sie sind nur innerhalb einer Zeichenfolge in Anführungszeichen zulässig, wie im folgenden Absatz beschrieben, und außerdem muss vor einem Backslash oder doppelten Anführungszeichen ein Backslash stehen). Kommentare sind erlaubt

  • mit runden Klammern an beiden Enden des lokalen Teils; z.B. john.smith(comment)@example.com und (comment)[email protected] sind beide äquivalent zu [email protected];

Der Code, den ich verwende, lässt keine unzulässigen Sonderzeichen zu, bietet jedoch wesentlich mehr Optionen als die meisten Antworten. Ich würde es vorziehen, die Validierung lockerer zu gestalten, als Fehler auf der Seite der Vorsicht.

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

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: enteredText)
0
JavaBeast

Da es jetzt so viele seltsame Top-Level-Domainnamen gibt, höre ich auf, die Länge der Top-Level-Domain zu überprüfen ...

Folgendes verwende ich:

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)
    } 
}
0
snowmen10
//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% arbeiten und getestet

0

Scheint auch zu funktionieren ...

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

Ich erstelle gerne eine Erweiterung

   extension String {

func isValidateEmail() -> 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: self)
}

}

verwendungszweck:

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

}
0
siva kumar

Und für Swift:

extension String {
    func isValidEmail() -> Bool {
        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: NSMakeRange(0, self.characters.count)) != nil
    }
}
0
Danut Pralea

Aktualisierte Antwort @Arsonik Antwort auf Swift 2.2 mit weniger ausführlichem Code als bei anderen angebotenen Lösungen:

extension String {
    func isValidEmail() -> Bool {
        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?.firstMatchInString(self, options: [], range: NSMakeRange(0, self.characters.count)) != nil
    }
}
0
Matias Seijas

Mein einziger Zusatz zur Liste der Antworten wäre, dass es für Linux NSRegularExpression nicht gibt, es ist tatsächlich 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

Dies kann sowohl unter MacOS als auch unter Ubuntu erfolgreich kompiliert werden.

0
Andrei Popa

Für alle, die noch nach einer Antwort suchen, schauen Sie sich bitte das folgende Framework an.

ATGValidator

Es handelt sich um ein regelbasiertes Validierungsframework, das die meisten Standardvalidierungen durchführt. Und obendrein gibt es form validator, mit dem mehrere Textfelder gleichzeitig validiert werden können.

Verwenden Sie zum Überprüfen einer E-Mail-Zeichenfolge Folgendes:

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

Wenn Sie eine E-Mail aus dem Textfeld validieren möchten, versuchen Sie es mit dem folgenden 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()

Fügen Sie eine der folgenden Zeilen hinzu, wenn Sie es während der Eingabe in ein Textfeld oder wenn der Fokus in ein anderes Feld geändert wird, überprüfen möchten.

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

Weitere Anwendungsfälle finden Sie in der Readme-Datei unter Link .

0
Suran

@ JeffersonBes Antwort ist knapp, aber es wird true zurückgegeben, wenn die Zeichenfolge "irgendetwas enthält, das [email protected] enthält, eine gültige E-Mail-Adresse", die wir nicht wollen. Das Folgende ist eine Erweiterung von String, die gut funktioniert (und das Testen auf gültige phoneNumber- und andere Datendetektoren ermöglicht, um zu starten.

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