स्विफ्ट में ई-मेल पता कैसे मान्य करें?

338

क्या कोई जानता है कि स्विफ्ट में ई-मेल पते को कैसे मान्य किया जाए? मुझे यह कोड मिला:

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

लेकिन मैं इसे स्विफ्ट में ट्रांसलेट नहीं कर सकता।

ios  validation  email  swift 
— जियोर्जियो नोकेरा
स्रोत
8
अनुवाद सीधा होना चाहिए। क्या हिस्सा आपको समस्याएं दे रहा है?
— सुल्तान
12
यह प्रार्थना करना न भूलें कि आपके किसी भी उपयोगकर्ता के पास नए शीर्ष स्तर के डोमेन में से एक नहीं है। उदा.coffee
— मथायस बाउच
1
@Antzi: मैंने "किसी @ @ जीमेल" से जाँच की और आपका रेगेक्स सही निकला।
— एक
2
Regexes यह पुष्टि करने के लिए काम नहीं करता है कि उपयोगकर्ताओं ने अपना ई-मेल पता दर्ज किया है। एक सक्रिय ई-मेल भेजने के लिए केवल 100% सही तरीका है। देखें: मैं जानता था कि जब तक मैं RFC
— पढ़ता
2
यह एक आकर्षक क्यूए है। यह लगभग निश्चित रूप से पूरी साइट पर "सबसे गलत" क्यूए है। वर्तमान में # 1 जवाब 600 वोटों के साथ (क्या ?!) बिल्कुल, पूरी तरह से, हर संभव तरीके से गलत है (प्रत्येक व्यक्तिगत पंक्ति पूरी तरह से गलत है, और हर अवधारणा और विचार गलत है ........ !!!) अन्य अत्यधिक वोट किए गए जवाबों में से कई या तो "पूरी तरह से गलत", "बेहद चमकदार", या, सादे टूटे हुए हैं और संकलन भी नहीं हैं। इसके अलावा, जबकि इस क्यू की प्रकृति "अभिजात वर्ग के रेक्सक्स इंजीनियरिंग" के लिए कहती है, कई उत्तर (अत्यधिक मतदान!) फीचर को पुनःसक्रिय इंजीनियरिंग कहते हैं। यह वास्तव में दिलचस्प क्यूए है !! क्यों??
— फेटी

जवाबों:

769

मैं उपयोग करेगा 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)
}

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

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
}
— मैक्सिम शाओतिन
स्रोत
6
नहीं होगा return emailTest.evaluateWithObject(testStr)एक बहुत अधिक सरल और पठनीय हो सकता है? तुलना करना == trueथोड़ा जावास्क्रिप्ट की तरह है।
— सुल्तान
15
यह जाँच नहीं करता है कि क्या कोई एक्सटेंशन उपलब्ध है, एक @ एक पहले से ही ठीक है :(
— CularBytes
6
यह परीक्षण @ परीक्षण के लिए मान्य नहीं है ... com
— एलन
3
यह ईमेल का पता नहीं लगाता है। @ अमान्य.com या ईमेल @ .invalid.com। @Alexcristea से नीचे का उत्तर है
— बेन सुलिवन
3
यह काफी मज़ेदार है कि ............ और साथ ही (1) regex पूरी तरह से गलत है , पूरी तरह से गलत (2) regex (यहां तक ​​कि यह क्या करने की कोशिश कर रहा है के संदर्भ में) बड़ी त्रुटियां हैं ( 3) स्विफ्ट गलत है (4) यहां तक ​​कि सेटिंग भी अलग है, शैली पूरी तरह से गलत है (5) ऐसा नहीं है कि यह सभी बाकी दिए गए मामलों पर निर्भर करता है, लेकिन यह भी उल्लेख नहीं करता है कि आपको विधेय को कैश करना होगा ... विनोदपूर्वक, ( 6) वहाँ अभी भी कोड ("कैलेंडर" पर छोड़ दिया है - क्या?) जहाँ से इसे कॉपी किया गया था।
— फेटी
115

संपादन, स्विफ्ट 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)

}

स्विफ्ट 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)

}

यह ठीक काम कर रहा है।

— अज़िक अब्दुल्ला
स्रोत
2
एक वैध रेगेक्स के साथ पहला। दूसरों को सही पर आ @ Aach मान्य
— netshark1000
1
@ netshark1000, केवल upvotes के साथ, कोई भी उत्तर शीर्ष पर होगा। :)
— अज़िक अब्दुल्ला
NSRegularExpression NSPredicate की तुलना में उपयोग करने के लिए सरल है
— Guillaume लॉरेंट
1
यह डोमेन नाम के बाद दो डॉट्स कंडीशन को हैंडल नहीं करता है। इस उत्तर का प्रयास करें stackoverflow.com/a/53441176/5032981
— प्रशांत गायकवाड़
@AzikAbdullah यदि आप 'abc @ gmail..com' दर्ज करते हैं तो यह भी मान्य होगा
— Nij
110

एक Stringवर्ग विस्तार के रूप में

स्विफ्ट 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() {

}
— Arsonik
स्रोत
4
countElementsअब हैcount
— ज़ैक शापिरो
25
xxx @ yyy वापसी सच?
— कलन रवि
1
कलन सन के रूप में भी, फू @ बार वापसी सच है।
— रेमी वीरिन
3
user @ host without .tld भी एक मान्य ईमेल पता है, जैसे रूट @ localhost
— बुध
1
ध्यान दें कि NSRange लंबाई संपत्ति characters.count के बजाय स्ट्रिंग utf16.count का उपयोग करना चाहिए
— सिंह Dabus
64

यदि आप ऐसा करने के लिए एक साफ और सरल उपाय की तलाश में हैं, तो आपको https://github.com/nsagora/validation-compenders पर एक नज़र डालनी चाहिए ।

इसमें एक ईमेल सत्यापन शामिल है जो आपके कोड में आसान एकीकृत है:

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

हुड के पीछे यह RFC 5322 reg पूर्व ( 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])+)\\])"
— alexcristea
स्रोत
3
वाह, emailregex.com के बारे में नहीं पता था। ये अदभुत है!
— सैमुअल ईव
2
अंत में, एक जो ईमेल को फिल्टर करता है। @ email.com
— बेन सुलिवन
यह सटीक - abcd@abcd.com के साथ काम कर रहा है। यह मान्य नहीं है abc @ abc
— अनिल गुप्ता
आह, अंत में ..: D
— ñmañg åürmån
39

यहाँ उचित समाधान है:

"उचित समाधान"

कई विशाल मात्रा वाले ऐप्स में वर्षों तक उपयोग और परीक्षण किया गया।

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" का अर्थ है साधारण वर्ण - एक अक्षर या एक अंक।

__firstpart ... को OC के साथ शुरू और समाप्त करना है। बीच के पात्रों के लिए आपके पास कुछ पात्र हो सकते हैं जैसे कि अंडरस्कोर, लेकिन शुरुआत और अंत में एक OC होना चाहिए। (हालांकि, केवल एक OC होना ठीक है और यह उदाहरण के लिए: j@blah.com है)

__serverpart ... आपके पास "blah" जैसे अनुभाग हैं। जो दोहराते हैं । (तो mail.city.fcu.edu प्रकार की बात।) अनुभागों को OC के साथ शुरू और समाप्त करना पड़ता है , लेकिन बीच में आपके पास एक डैश भी हो सकता है "-"। (यदि आप वहां अन्य असामान्य वर्णों को अनुमति देना चाहते हैं , तो शायद अंडरस्कोर, केवल डैश से पहले जोड़ दें।) यह ठीक है एक अनुभाग है जो सिर्फ एक ओसी है। आप पांच वर्गों तक हो सकती हैं (joe@w.campus.edu में के रूप में), तो आप के लिए है एक है। अंत में टीएलडी (जैसे .com) का आकार कड़ाई से 2 से 8 है । जाहिर है, बस उस "8" को अपने समर्थन विभाग द्वारा पसंद के अनुसार बदल दें।

जरूरी !

आपको एक वैश्विक के रूप में विधेय को रखना चाहिए, हर बार इसका निर्माण न करें।

ध्यान दें कि यह पहली बात है कि Apple डॉक्स में पूरे मुद्दे के बारे में उल्लेख करता है ।

यह बहुत आश्चर्य की बात है जब आप सुझावों को देखते हैं जो विधेय को कैश नहीं करते हैं।

— fattie
स्रोत
1
क्या यह नए TLDs का समर्थन करता है .engineer?
— रोमन
हाय @ रमन - नोटिस जहां यह स्पष्ट रूप से कहता है "अंत में टीएलडी (.com या लाइक) कड़ाई से 2 से 8 अक्षर हैं।" जो इसका ख्याल रखता है। आप "8" को अपनी पसंद के मान में बदल सकते हैं। (अभी के लिए, कई बड़ी कंपनियों में, ग्राहक सेवा किसी भी लंबे TLDs को केवल एक घोटाले के रूप में अस्वीकार कर देगी - लेकिन वैसे भी, यह आपका निर्णय है, "8" या आपके द्वारा किसी भी मूल्य का उपयोग करें।)
— Fattie
2
बिंदु (4) के संबंध में: आपने कितने उपयोगकर्ताओं के साथ परीक्षण किया? क्या आपने उपयोगकर्ताओं को ट्रैक किया था, जो वाणिज्यिक ऐप के साथ साइन अप नहीं कर सकते थे, क्योंकि रेगेक्स ने उन्हें अपने ईमेल पते का उपयोग करने से रोक दिया था? एकमात्र "उचित" होना चाहिए, क्या युक्ति (RFC) निर्दिष्ट करता है या यदि यह प्राप्त नहीं किया जा सकता है, तो कुछ ऐसा है जो अधिक आराम से है, लेकिन कल्पना से सब कुछ कवर करता है। यदि उपयोगकर्ताओं को x @ x में प्रवेश करने की अनुमति नहीं है, तो वे कुछ gar@@ampleample.com दर्ज करेंगे, जो आपके / किसी भी regex को पारित कर देगा।
— द ट्रॉटज़ ज़ूल
hi @thetrutz, "garbage@example.com" एक बिलकुल सामान्य ईमेल पता है। RFC में "x @ x" जैसे सैद्धांतिक मुहावरे शामिल हैं। आपके या मेरे द्वारा कभी भी काम करने वाले किसी भी वास्तविक वाणिज्यिक ग्राहक को "उन लोगों को अस्वीकार करना" कहा जाएगा। (ध्यान दें कि किसी भी वास्तविक दुनिया के बड़े व्यवसाय में, यहाँ मेरे मोटे तौर पर रूपरेखा की तुलना में बहुत अधिक प्रतिबंध हैं, जैसा कि मैंने ऊपर रोमन में टिप्पणी में उल्लेख किया है।) आपका अंतिम वाक्य भ्रामक है - बेशक एक "गैर-कामकाजी ईमेल" किसी को भी पारित कर देगा। स्थानीय परीक्षण? क्या मतलब? जाहिर तौर पर ईमेल केवल "आपके ईमेल की पुष्टि करें" सिस्टम के माध्यम से सत्यापित होते हैं।
— फेटी जूल
स्विफ्ट में हर प्रक्रिया को अनुकूलित करने की आवश्यकता है क्योंकि हम आमतौर पर सर्वर साइड पर इस भाषा का उपयोग करते हैं।
— निकोलस मांजिनी 14
25

यहाँ सही regex के साथ दो सबसे अधिक मतदान के जवाब का एक फ्यूज है: स्ट्रिंग का विस्तार करके विधेय का उपयोग करें ताकि आप 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)
        }
    }
— निकोलस मंज़िनी
स्रोत
19

स्विफ्ट 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
— केन मुलर
स्रोत
2
दोहराए गए उत्तर को दोहराने की बात क्या है? जो किसी भी 5 स्विफ्ट 5 विशेषताओं पर निर्भर नहीं करता है
— 9
17

मैं इसे स्ट्रिंग के विस्तार के रूप में उपयोग करने का सुझाव दूंगा: 

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")
}
— JeffersonBe
स्रोत
1
ध्यान दें कि NSRange लंबाई संपत्ति characters.count के बजाय स्ट्रिंग utf16.count का उपयोग करना चाहिए
— सिंह Dabus
अद्यतन स्विफ्ट 4: एक्सटेंशन स्ट्रिंग {सार्वजनिक संस्करण ismail: बूल {डेटाडेटेटर = आज़माएं? NSDataDetector (प्रकार: NSTextCheckingResult.CheckingType.link.rawValue) FirstMatch = dataDetector? .FirstMatch (में: स्वयं, विकल्प: NSRegideExpression.MatchingOptions.reportCompletion, श्रेणी: NSRange (स्थान: 0, लंबाई): लंबाई, लंबाई। range.location! = NSNotFound && FirstMatch? .url? .scheme == "mailto")}
— Duan Nguyen
15

यह स्विफ्ट 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
    }
}
— जोएल गार्सिया वेरस्टिका
स्रोत
8
foo @ बार सही है!
— रेमी वीरिन
2
मान्य @ आच सच
— netshark1000
4
ऐसा इसलिए है क्योंकि RFC इन ईमेल को सही
— मानता
ध्यान दें कि NSRange लंबाई संपत्ति characters.count के बजाय स्ट्रिंग utf16.count का उपयोग करना चाहिए
— सिंह Dabus
यह वास्तव में गलत / गरीब है कि विधेय को कैश न करें। यह पहली बात है कि Apple ने डोको में इस मुद्दे के बारे में कहा है। पृष्ठ पर अधिकांश उत्तरों द्वारा की गई एक भयावह गलती।
— फेटी
9

यहाँ बहुत सारे सही उत्तर हैं, लेकिन कई "रेगेक्स" अधूरे हैं और ऐसा भी हो सकता है कि: "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
        }
    }
}
— Andrea.Ferrando
स्रोत
ठीक से काम नहीं करता है, यह आपको डोमेन के बाद रिक्त स्थान जोड़ने देता है।
— जुआन बोइरो
ध्यान दें कि NSRange लंबाई संपत्ति characters.count के बजाय स्ट्रिंग utf16.count का उपयोग करना चाहिए
— सिंह Dabus
@ फटी ने आपके बयान पर बहस की। आपकी टिप्पणी बहुत बेकार है, एक सुधार का सुझाव दें, एक प्रस्ताव का प्रस्ताव करें। पूरी तरह से गलत कहना बहुत बेवकूफी है और एक करीबी मानसिकता को रेखांकित करता है
— Andrea.Ferrando
"यहाँ बहुत सारे सही उत्तर हैं" यह वाक्य बहुत ही गलत है :) :)
— Fattie
8

यहाँ एक विधि पर आधारित है 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 लंबाई।

यहां RFC 5322 के अनुसार ईमेल के लिए निश्चित RegEx है, ध्यान दें कि यह सबसे अच्छा उपयोग नहीं किया जाता है क्योंकि यह केवल ईमेल पते के मूल सिंटैक्स की जांच करता है और जांच नहीं करता है कि शीर्ष स्तर डोमेन मौजूद है।

([एक-Z0-9 # $% & '* + / = ^ _ `{|} ~ - + (?।!: \ [एक-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] (?: [] एक-Z0-9 -] * [एक-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] | [एक-Z0-9 -] * [एक करने के लिए Z0-9]:
          (: [\ X01- \ x08 \ x0b \ x0c \ x0e- \ x1f \ x21- \ x5a \ x53- \ x7f]
          | \\ [\ x01- \ x09 \ x0b \ x0c \ x0e- \ x7f]) +)
     \])

देखें Regular-Expressions.info ईमेल RegExs पर अधिक पूर्ण जानकारी के।

ध्यान दें कि ऑब्जेक्टिव-सी या स्विफ्ट जैसी भाषा से कोई बच नहीं सकता है।

— zaph
स्रोत
1
आपके द्वारा उपयोग किया जाने वाला emailRegEx सिर्फ सादा गलत है। यह केवल TLDs 2 से 4 वर्णों के लिए अनुमति देता है, जबकि डोमेन जैसे .engineerमौजूद हैं।
— अंतीज
समझे, मैं अपने उत्तर का बचाव नहीं कर रहा हूं, लेकिन संपादन का स्तर। ऊपर टिप्पणी के रूप में, नीचे-वोट दें, बेहतर उत्तर की ओर इंगित करें, अपना स्वयं का उत्तर जोड़ें। उत्तर को बदलना काफी हद तक उचित नहीं है। मैंने पूर्णता के लिए विवादास्पद RegEx को जोड़ा है।
— जफ
ओह, क्यों नहीं बस जवाब हटा दें? इसे यहां रखने के क्या संभावित कारण हो सकते हैं?
— फेटी
7

मैं इसके लिए एक एक्सटेंशन का उपयोग करना पसंद करता हूं। इसके अलावा, यह 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)
    }
}
— मार्लोन रुइज़
स्रोत
कुछ समस्याएं हैं .. आप उदाहरण के लिए .. blah @ .abc को एक अजीब बिंदी के साथ रख सकते हैं
— Fattie
5

स्विफ्ट 2.1 के लिए: यह ईमेल foo @ बार के साथ सही ढंग से काम करता है

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
        }
    }
}
— lee5783
स्रोत
1
यह मेरे लिए ठीक काम लगता है। जहाँ तक मैं समझता हूँ कि आपके पास विकल्प होने के बाद भी आप 'AZ' (बड़े अक्षरों) को छोड़ सकते हैं। कुछ भी सेट कर सकते हैं।
— AZOM
ध्यान दें कि NSRange लंबाई संपत्ति characters.count के बजाय स्ट्रिंग utf16.count का उपयोग करना चाहिए
— सिंह Dabus
5

स्विफ्ट का उपयोग 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 
    {

    }
— इकबाल
स्रोत
4

@Fattie द्वारा "THE REASONABLE SOLUTION" के लिए यह एक नया संस्करण है , जिसे स्विफ्ट 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मेरी समझ से बेहतर होगी ।

— एलेजांद्रो इवान
स्रोत
2

सरल एक्सटेंशन बनाएं:

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आदि ...

— बार्टोलोमिएज सेमेकोज़ी
स्रोत
ध्यान दें कि NSRangeलंबाई संपत्ति के String utf16.countबजाय का उपयोग करना चाहिएcharacters.count
— लियो डबस
2

में स्विफ्ट 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
}
— आईओएस
स्रोत
1

मैंने इनपुट मान्यताओं के लिए डिज़ाइन की गई एक लाइब्रेरी बनाई और "मॉड्यूल" में से एक आपको आसानी से सामान का एक गुच्छा मान्य करने की अनुमति देता है ...

एक ईमेल को मान्य करने के लिए उदाहरण के लिए:

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

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

SwiftCop लाइब्रेरी है ... उम्मीद है कि यह मदद करेगा!

— एन्ड्रेस
स्रोत
1

यहां स्विफ्ट 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
}
— गेफ़िल्टे मछली
स्रोत
एलेक्सजिस्टीया के जवाब से रेगेक्स का उपयोग करने के लिए बदलना, यह सही समाधान है।
— ittgung
0

चूंकि अब कई अजीब शीर्ष स्तर डोमेन नाम हैं, इसलिए मैं शीर्ष डोमेन की लंबाई की जांच करना बंद कर देता हूं ...

यहाँ मेरा उपयोग है:

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)
    } 
}
— snowmen10
स्रोत
0

काम भी लगता है ...

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
}
— Logicopolis
स्रोत
0

उत्तर दिए गए उत्तर @ स्विसन 2.2 का स्विफ्ट 2.2, अन्य प्रस्तावित समाधानों की तुलना में कम वर्बोस कोड का उपयोग करते हुए:

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
    }
}
— मतिस सेजस
स्रोत
abcd @ a इस regex के साथ गुजर रहा है। आपको इसे ठीक करना चाहिए।
— गुंजन
ध्यान दें कि NSRange लंबाई संपत्ति characters.count के बजाय स्ट्रिंग utf16.count का उपयोग करना चाहिए
— सिंह Dabus
0

@ JeffersonBe का जवाब करीब है, लेकिन trueअगर स्ट्रिंग "कुछ है जिसमें some@something.com एक वैध ईमेल है" जो कि वह नहीं है जो हम चाहते हैं। निम्नलिखित स्ट्रिंग पर एक विस्तार है जो अच्छी तरह से काम करता है (और वैध फोननंबर और अन्य डेटा डिटेक्टरों को बूट करने के लिए परीक्षण की अनुमति देता है।

/// 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
}
— Gujamin
स्रोत
ध्यान दें कि NSRange लंबाई संपत्ति characters.count के बजाय स्ट्रिंग utf16.count का उपयोग करना चाहिए
— सिंह Dabus
0

और स्विफ्ट 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
    }
}
— दानुत प्रालि
स्रोत
ध्यान दें कि NSRange लंबाई संपत्ति characters.count के बजाय स्ट्रिंग utf16.count का उपयोग करना चाहिए
— सिंह Dabus
0

प्रतिक्रियाओं की सूची में मेरा एकमात्र जोड़ यह होगा कि लिनक्स के लिए, 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 दोनों पर सफलतापूर्वक संकलित होता है।

— आंद्रेई पोपा
स्रोत
ध्यान दें कि NSRange लंबाई संपत्ति characters.count के बजाय स्ट्रिंग utf16.count का उपयोग करना चाहिए
— सिंह Dabus
0

के लिए सबसे अच्छा परिणाम के साथ सबसे अच्छा समाधान

स्विफ्ट 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)
        }
    }
— अब्देलहद दरविश
स्रोत
0

मुझे एक्सटेंशन बनाना पसंद है 

   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.

}
— शिव कुमार
स्रोत
0

स्विफ्ट 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)
— आरफिन रसेल
स्रोत
0

Google ईमेल की तरह परफेक्ट रेगेक्स

"^[A-Z0-9a-z][a-zA-Z0-9_.-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}"
— ami आरटी
स्रोत
2
जो कोई भी मेरा जवाब दे, कृपया अपना ज्ञान जांचें। मैंने इस regex को कई कोड में लागू किया है और मेरे दोस्त मेरे इस regex का उपयोग कर रहे हैं और यह बहुत अच्छा काम करता है। मेरे वोट का जवाब दें। कृपया कमेंट करें और मुझे बताएं कि इस regex में क्या गलत है।
— ami rt
मुझे लगता है कि मैं जवाब दे सकता हूं: आपका regex सरल है और RFC से मेल नहीं खाता है। उदाहरण के लिए, ईमेल में पहले भाग में उद्धरण और रिक्त स्थान हो सकते हैं! Haacked.com/archive/2007/08/21/…
— हुगल 31
1
क्षमा करें, भाई, मुझे लगता है कि आपको Google ईमेल सत्यापन की जांच करनी चाहिए, ईमेल के पहले भाग में स्पेस जोड़ने का कोई तरीका नहीं है, और यदि मेरा regex गलत है, तो कोई भी पोस्ट लिखने और सही regex क्यों नहीं करता है।
— ami rt
RFC 5322 के अनुसार, "हैलो वर्ल्ड!" @ Example.com एक वैध ईमेल है। वास्तव में, वैध रेगीक्स बनाना लगभग असंभव है। हर मेल प्रदाता Google ईमेल सत्यापन से नहीं चिपकेगा।
— हुगल ३१
1
Thats जो मैं सुनना चाहता हूं, और यही कारण है कि मैंने बोल्ड हेडिंग में उल्लेख किया है कि ऊपर रेगेक्स Google जैसा है। धन्यवाद
— अमी आरटी
-1

या आपके पास 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
    }
}
— मैकीज चर्जास्टेक
स्रोत
ध्यान दें कि NSRange लंबाई संपत्ति characters.count के बजाय स्ट्रिंग utf16.count का उपयोग करना चाहिए
— सिंह Dabus
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.