ไม่มีใครรู้วิธีการตรวจสอบที่อยู่อีเมลใน Swift? ฉันพบรหัสนี้:

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

แต่ฉันแปลมันเป็นสวิฟต์ไม่ได้

ฉันจะใช้NSPredicate:

func isValidEmail(_ email: 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: email)
}

สำหรับ Swift เวอร์ชันก่อนหน้า 3.0:

func isValidEmail(email: 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: email)
}

สำหรับ Swift เวอร์ชันก่อนหน้า 1.2:

func isValidEmail(email: 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(email)
    }
    return false
}

การแก้ไขอัปเดตสำหรับ 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)

}

คำตอบต้นฉบับสำหรับ 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)

}

มันทำงานได้ดี

เป็นการ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
    }
}

การใช้

if "rdfsdsfsdfsd".isValidEmail() {

}

หากคุณกำลังมองหาวิธีการแก้ปัญหาที่สะอาดและง่ายต่อการทำเช่นนี้คุณควรจะดูที่https://github.com/nsagora/validation-components

มันมีภาคการตรวจสอบอีเมลซึ่งเป็นเรื่องง่ายที่จะรวมในรหัสของคุณ:

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

ด้านหลังประทุนจะใช้ 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])+)\\])"

นี่คือทางออกที่สมเหตุสมผล:

"ทางออกที่เหมาะสม"

ใช้และทดสอบมานานหลายปีในแอปมากมายที่มีปริมาณมาก

1 - หลีกเลี่ยงข้อผิดพลาด regex ที่น่ากลัวมากมายที่คุณมักจะเห็นในคำแนะนำเหล่านี้

2 - ไม่อนุญาตให้ใช้อีเมลที่โง่เช่น "x @ x" ซึ่งคิดว่าถูกต้องภายใต้ RFC บางตัว แต่มันโง่มากไม่สามารถใช้เป็นอีเมลได้และพนักงานฝ่ายสนับสนุนของคุณจะปฏิเสธทันที บริการจดหมาย (mailchimp, google, aws ฯลฯ ) เพียงปฏิเสธ หาก (ด้วยเหตุผลบางอย่าง) คุณต้องการโซลูชันที่อนุญาตให้ใช้สตริงเช่น 'x @ x' ให้ใช้โซลูชันอื่น

3 - รหัสนั้นมากมาก ๆ เป็นที่เข้าใจได้มาก

4 - เป็น KISS เชื่อถือได้และทดสอบเพื่อทำลายแอพเชิงพาณิชย์ที่มีผู้ใช้จำนวนมาก

5 - จุดเทคนิคการวินิจฉัยเป็นทั่วโลกเช่นแอปเปิ้ลกล่าวว่ามันควรจะเป็น (ดูออกสำหรับข้อเสนอแนะรหัสซึ่งไม่ได้นี้)

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

มันง่ายมาก

คำอธิบาย:

ในคำอธิบายต่อไปนี้ "OC" หมายถึงอักขระธรรมดา - ตัวอักษรหรือตัวเลข

__ ก่อนอื่น ... ต้องเริ่มต้นและจบด้วย OC สำหรับตัวละครที่อยู่ตรงกลางคุณสามารถมีตัวละครบางตัวเช่นขีดล่าง แต่จุดเริ่มต้นและจุดสิ้นสุดจะต้องเป็น OC (อย่างไรก็ตามมันก็โอเคที่จะมีเพียงหนึ่ง OC และนั่นคือตัวอย่างเช่น: j@blah.com)

__serverpart ... คุณมีส่วนต่างๆเช่น "blah" ซึ่งการทำซ้ำ (ดังนั้นประเภทของสิ่งของ mail.city.fcu.edu) ส่วนต่างๆจะต้องเริ่มต้นและสิ้นสุดด้วย OC แต่ตรงกลางคุณสามารถมีเครื่องหมายขีดกลาง "-" (หากคุณต้องการอนุญาตให้มีตัวละครที่ผิดปกติอื่น ๆในนั้นอาจขีดเส้นใต้เพียงแค่เพิ่มก่อนที่จะรีบ) มันก็โอเคที่จะมีส่วนที่เป็นเพียงหนึ่ง OC (เช่นเดียวกับ joe@w.campus.edu) คุณสามารถมีได้สูงสุดห้าส่วนคุณต้องมีหนึ่งส่วน สุดท้ายTLD (เช่น .com) เป็นอย่างเคร่งครัด 2-8 ในขนาดเห็นได้ชัดว่าเพียงแค่เปลี่ยน "8" ตามต้องการโดยแผนกสนับสนุนของคุณ

สำคัญ !

คุณต้องทำให้ภาคแสดงเป็นโลกอย่าสร้างมันทุกครั้ง

โปรดทราบว่านี่เป็นสิ่งแรกที่ Apple กล่าวถึงเกี่ยวกับปัญหาทั้งหมดในเอกสาร

มันน่าประหลาดใจมากเมื่อคุณเห็นข้อเสนอแนะที่ไม่แคชเพรดิเคต

นี่คือฟิวส์ของคำตอบที่ได้รับการโหวตมากที่สุดสองข้อด้วย regex ที่ถูกต้อง: ส่วนขยาย String โดยใช้เพรดิเคตเพื่อให้คุณสามารถเรียกใช้ 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)
        }
    }

วิธีที่ง่ายที่สุดใน Swift 5

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

ตัวอย่าง

"kenmueller0@gmail.com".isValidEmail

ผลตอบแทน ...

true

ฉันขอแนะนำให้ใช้เป็นส่วนเสริมของ 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
    }
}

และใช้มัน:

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

นี่เป็นเวอร์ชั่นที่อัปเดตสำหรับ 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
    }
}

มีคำตอบที่ถูกต้องมากมายที่นี่ แต่ "regex" จำนวนมากไม่สมบูรณ์และอาจเกิดขึ้นได้ว่าอีเมลเช่น: "name @ domain" ส่งผลให้อีเมลที่ถูกต้อง แต่ไม่ใช่ นี่คือทางออกที่สมบูรณ์:

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

นี่คือวิธีการตาม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
}

หมายเหตุ: ความยาว TLD ที่อัปเดต

นี่คือ RegEx ที่ชัดเจนสำหรับอีเมลตาม RFC 5322 โปรดทราบว่านี่ไม่ได้ใช้ดีที่สุดเพราะจะตรวจสอบไวยากรณ์พื้นฐานของที่อยู่อีเมลเท่านั้นและไม่ได้ตรวจสอบว่ามีโดเมนระดับบนสุดอยู่แล้ว

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

ดูRegular-Expressions.infoสำหรับข้อมูลที่สมบูรณ์เพิ่มเติมเกี่ยวกับอีเมล RegExs

โปรดทราบว่าไม่มีการหลบหนีตามที่ต้องการโดยภาษาเช่น Objective-C หรือ Swift

ฉันชอบใช้ส่วนขยายสำหรับสิ่งนั้น นอกจากนี้ URL นี้http://emailregex.comสามารถช่วยคุณทดสอบว่า regex นั้นถูกต้องหรือไม่ ในความเป็นจริงเว็บไซต์มีการใช้งานที่แตกต่างกันสำหรับบางภาษาการเขียนโปรแกรม ผมร่วมการดำเนินงานของฉันสำหรับสวิฟท์ 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)
    }
}

สำหรับ swift 2.1: สามารถทำงานได้อย่างถูกต้องกับอีเมล 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
        }
    }
}

การใช้ 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
    } }

และใช้แล้ว

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

    }

นี่เป็นเวอร์ชั่นใหม่สำหรับ"THE REASONABLE SOLUTION"โดย @Fattie ทดสอบกับ Swift 4.1 ในไฟล์ใหม่ที่เรียกว่า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)
    }
}

ดังนั้นการใช้งานจึงเป็นเรื่องง่าย:

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

ฉันก็ไม่ชอบที่จะเพิ่มfuncไปยังStringวัตถุที่เป็นที่อยู่อีเมลมีอยู่กับพวกเขา (หรือไม่) ดังนั้นBoolทรัพย์สินจะพอดีดีกว่าfuncจากความเข้าใจของฉัน

สร้างส่วนขยายอย่างง่าย:

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

ตัวอย่าง:

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

คุณสามารถขยายต่อไปนี้ขยายไปยังสิ่งที่คุณต้องการ: isValidPhoneNumber, isValidPasswordฯลฯ ...

ในSwift 4.2และ 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")
}

หากคุณต้องการใช้ 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() {

}
}

และฟังก์ชั่นการโทรแบบนี้ ....

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

ฉันสร้างไลบรารีที่ออกแบบมาสำหรับการตรวจสอบความถูกต้องของอินพุตและหนึ่งใน "โมดูล" ช่วยให้คุณสามารถตรวจสอบสิ่งต่าง ๆ ได้อย่างง่ายดาย ...

ตัวอย่างเช่นการตรวจสอบอีเมล:

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

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

SwiftCopเป็นห้องสมุด ... หวังว่ามันจะช่วยได้!

นี่คือส่วนขยายใน 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)
    }
}

เพียงใช้มันเช่นนี้

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

เนื่องจากมีชื่อโดเมนระดับบนสุดแปลกมากมายตอนนี้ฉันหยุดตรวจสอบความยาวของโดเมนด้านบน ...

นี่คือสิ่งที่ฉันใช้:

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

ดูเหมือนว่าจะทำงานด้วย ...

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
}

อัปเดตคำตอบ @Arsonik เพื่อ Swift 2.2 โดยใช้โค้ด verbose น้อยกว่าโซลูชันที่เสนออื่น ๆ :

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

คำตอบของ @ JeffersonBe อยู่ใกล้ แต่ส่งคืนtrueถ้าสตริงเป็น "สิ่งที่มี someone@something.com อีเมลที่ถูกต้อง" ซึ่งไม่ใช่สิ่งที่เราต้องการ ต่อไปนี้เป็นส่วนขยายของ String ที่ใช้งานได้ดี (และอนุญาตให้ทดสอบหมายเลขโทรศัพท์ที่ถูกต้องและเครื่องตรวจจับข้อมูลอื่น ๆ เพื่อเริ่มระบบ

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

และสำหรับ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
    }
}

สิ่งเดียวที่ฉันมีในรายการคำตอบคือสำหรับ Linux NSRegularExpressionไม่มีอยู่จริง ๆ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

การรวบรวมนี้ประสบความสำเร็จทั้งใน macOS และ Ubuntu

ทางออกที่ดีที่สุดด้วยผลลัพธ์ที่ดีที่สุดสำหรับ

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

ฉันชอบที่จะสร้างส่วนขยาย

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

}

การใช้งาน:

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

}

สวิฟท์ 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
}

แล้ว:

let validEmail = isValidEmailAddress(emailAddressString: "your@email.com")
print(validEmail)

Perfect Regex เช่น Google Email

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

หรือคุณสามารถมีส่วนขยายสำหรับข้อความเสริมของ UITextField:

วิธีใช้:

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

ส่วนขยาย:

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