Kaip greitai patikrinti el. Pašto adresą?

Ar kas nors žino, kaip patikrinti „Swift“ el. Pašto adresą? Radau šį kodą:

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

bet aš negaliu išversti į greitą.

255
24 авг. nustatė Giorgio Nocera 24 rug. 2014-08-24 14:15 '14, 14:15, 2014-08-24 14:15
@ 33 atsakymai
  • 1
  • 2

Norėčiau naudoti NSPredicate :

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

„Swift“ versijoms anksčiau nei 3.0:

  func isValidEmail(testStr:String) -> Bool { // print("validate calendar: \(testStr)") let emailRegEx = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,64}" let emailTest = NSPredicate(format:"SELF MATCHES %@", emailRegEx) return emailTest.evaluate(with: testStr) } 

„Swift“ versijoms, anksčiau nei 1.2:

  class func isValidEmail(testStr:String) -> Bool { println("validate calendar: \(testStr)") let emailRegEx = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,64}" if let emailTest = NSPredicate(format:"SELF MATCHES %@", emailRegEx) { return emailTest.evaluateWithObject(testStr) } return false } 
637
24 авг. Maxim Shoustin atsakymas 24 rug 2014-08-24 14:20 '14, 14:20, 2014-08-24 14:20

Kaip String klasės išplėtimas

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.!#$% options: .caseInsensitive) return regex.firstMatch(in: self, options: [], range: NSRange(location: 0, length: count)) != nil } } 

naudoti

 if "rdfsdsfsdfsd".isValidEmail() { } 
96
22 окт. atsakymą pateikė Arsonik spalio 22 d 2014-10-22 11:27 '14 at 11:27 2014-10-22 11:27

Redagavimas atnaujintas „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) } 

Originalus atsakymas „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) } 

Tai puikiai veikia.

93
04 марта '16 в 9:12 2016-03-04 09:12 Atsakymą pateikė Azik Abdullah kovo 4 d. 16 d. 9:12 2016-03-04 09:12

Jei ieškote švaraus ir paprasto sprendimo, turėtumėte pažvelgti į https://github.com/nsagora/validation-components .

Jame yra el. Pašto patvirtinimo predikatas, kuris lengvai integruojamas į jūsų kodą:

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

RFC 5322 reg ex ( http://emailregex.com ) naudojamas už gaubto:

 let regex = "(?:[\\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])+)\\])" 
39
17 сент. atsakymas pateikiamas alexcristea 17 sep . 2016-09-17 22:11 '16 at 10:11 pm 2016-09-17 22:11

Čia pateikiamas dviejų labiausiai atsakytų balsų saugiklis su teisinga reguliariąja išraiška: eilutės išplėtimas naudojant predikatą, kad galėtumėte skambinti 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) } } 
24
04 нояб. atsakymą pateikė Nicolas Manzini 04 lapkričio. 2015-11-04 17:39 '15, 17:39 pm 2015-11-04 17:39

Čia yra protingas sprendimas:

„TIKSLAS SPRENDIMAS“

Naudojamas ir išbandytas per daugelį metų daugybėje didelių tūrių.

1 - tai vengia daugelio labai reguliarių klaidų, kurias dažnai matote šiuose sakiniuose.

2 - tai neleidžia kvailioms raidėms, pvz., „X @x“, kurios yra techniškai pagrįstos, bet visiškai kvailos - ir jūsų pagalbinis personalas ir tt bet kuriuo atveju nedelsiant atmestų. Jei jums reikia sprendimo, kuris leidžia kvailiems el. Laiškams, naudokite kitą sprendimą.

3 - tai labai aišku

4 yra KISS, patikimas ir išbandytas dėl sunaikinimo komerciniuose taikymuose su dideliu vartotojų skaičiumi

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

Paaiškinimas:

Toliau pateikiamame aprašyme „OC“ reiškia įprastą simbolį: kaip raidę ar skaičių.

„__firstpart“ turi prasidėti ir baigti „OC“. Viduryje esantiems simboliams gali būti neįprastų simbolių, pvz., Pabraukimo, bet pradžia ir pabaiga turi būti OC. (Galite turėti tik vieną OC, pvz., J@blah.com)

__serverpart ... Jūs turite sekcijų, pvz., „bla“. kuris kartojasi. (Taigi, type.city.fcu.edu tipas.) Skyriai turėtų prasidėti ir baigti OC, bet viduryje taip pat gali būti brūkšnys "-". (Jei norite, kad ten būtų kitų neįprastų simbolių, pvz., Pabraukimas, pridėkite juos prieš eilutę.) Gerai turėti skyrių, kuris yra tik vienas OC. (Kaip ir joe@w.campus.edu) Galite turėti iki penkių sekcijų; Turite turėti vieną. Galiausiai, ALD dydis (pvz., .Com) yra nuo 2 iki 8.

Atkreipkite dėmesį, kad jūs paprasčiausiai išsaugote predikatą kaip pasaulinį (trivialus Swift), todėl nereikia jo kiekvieną kartą sukurti.

Tai pirmas dalykas, kurį „Apple“ paminėjo dokumente.

Visi sprendimai, kurie, jūsų nuomone, nenaudoja visuotinio požiūrio, yra visiškai neteisingi.

18
21 янв. Atsakymas pateikiamas Fattie 21 jan. 2017-01-21 19:57 '17, 7:57 pm 2017-01-21 19:57

Tai atnaujinta versija „Swift 2.0“ - 2.2

  var isEmail: Bool { do { let regex = try NSRegularExpression(pattern: "^[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
30 сент. Atsakymas, kurį pateikė Joel García Verástica 30 Sep 2015-09-30 02:15 '15 at 2:15 2015-09-30 02:15

Siūlyčiau naudoti jį kaip eilutės plėtinį:

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

Ir naudokite:

 if "hodor@gameofthrones.com".isEmail { // true print("Hold the Door") } 
14
21 июня '16 в 15:55 2016-06-21 15:55 atsakymą pateikė JeffersonBe birželio 21 d., 16 val. 15:55 2016-06-21 15:55

Čia yra metodas, pagrįstas „ 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 } 

Pastaba: atnaujintas TLD ilgis.

Čia yra galutinis „RegEx“ el. Laiškas pagal RFC 5322, atkreipkite dėmesį, kad geriau jį nenaudoti, nes jis tik tikrina pagrindinę el. Pašto adresų sintaksę ir nekontroliuoja, ar yra aukščiausio lygio domenas.

   |  x (x: x08 x0b x0c x0- x1f x21 x23- x5b x5d- x7f)   |  x x x09 x0b x0c x0- x7f]) * ((a: (a: [a-z0-9] (a: [a-z0-9] * [a-z0-9]) a) + [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-08 x0b x0c x0- x1f x21- x5a x53- x7f)   |  x01-09 x0b x0c x0- x7f]) +)  ])

Daugiau informacijos apie „RegExs“ el. Laišką rasite „Regular-Expressions.info“.

Atkreipkite dėmesį, kad ekrano apsauga nereikalinga, kaip reikalaujama tokioje kalboje kaip „Objective-C“ arba „Swift“.

8
24 авг. atsakymas pateikiamas zaph 24 rug . 2014-08-24 15:49 '14 at 15:49 2014-08-24 15:49

Norėčiau naudoti šį pratęsimą. Be to, šis URL http://emailregex.com gali padėti jums patikrinti įprastą išraišką. Tiesą sakant, svetainė siūlo įvairias programas kai kurioms programavimo kalboms. Sutinku su Swift 3 įgyvendinimu.

 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
26 окт. atsakymą pateikė Marlon Ruiz spalio 26 d 2016-10-26 18:53 '16 at 18:53 pm 2016-10-26 18:53

Čia yra daug teisingų atsakymų, tačiau daugelis „reguliarių išraiškų“ yra neišsamūs, ir gali atsitikti, kad el. Čia pateikiamas išsamus sprendimas:

 extension String { var isEmailValid: Bool { do { let regex = try NSRegularExpression(pattern: "(?:[a-z0-9!#$%\\ options: .CaseInsensitive) return regex.firstMatchInString(self, options: NSMatchingOptions(rawValue: 0), range: NSMakeRange(0, self.characters.count)) != nil } catch { return false } } } 
6
26 февр. Andrea.Ferrando 26 vasario atsakymas 2016-02-26 15:23 '16 at 15:23 2016-02-26 15:23

Greitai 2.1: jis veikia teisingai su el. Pašto adresu 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 } } } 
5
29 янв. atsakymas, kurį pateikė lee5783 29 sausis 2016-01-29 22:13 '16 at 22:13 PM 2016-01-29 22:13

Aš sukūriau biblioteką įvesties tikrinimui, o vienas iš „modulių“ leidžia lengvai patikrinti daugybę dalykų ...

Pavyzdžiui, norėdami patikrinti el. Paštą:

 let emailTrial = Trial.Email let trial = emailTrial.trial() if(trial(evidence: "test@test.com")) { //email is valid } 

SwiftCop yra biblioteka ... Tikiuosi, kad tai padės!

2
05 нояб. Atsakymą pateikė Andres 05 lapkričio. 2015-11-05 15:44 '15 15:44 2015-11-05 15:44

Sukurkite paprastą plėtinį:

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

Pavyzdys:

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

Galite išplėsti šį išplėtimą į viską, ko reikia: isValidPhoneNumber , isValidPassword ir tt

2
10 мая '17 в 12:44 2017-05-10 12:44 Atsakymą pateikė Bartłomiej Semańczyk gegužės 10 d., „17, 12:44 2017-05-10 12:44

Naudojant „Swift“ 4.2

 extension String { func isValidEmail() -> Bool { let regex = try? NSRegularExpression(pattern: "^(((([a-zA-Z]|\\d|[!#\\$% 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 } } 

Ir naudojosi

 if (textField.text?.isValidEmail())! { // bla bla } else { } 
2
11 сент. Atsakymas, kurį pateikė ikbal Sep 11 2018-09-11 22:12 '18, 10:12 pm 2018-09-11 22:12

Tai nauja versija iš @Fattie REASONABLE SOLUTION“ , išbandyta „Swift 4.1“ naujame faile, pavadintame 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) } } 

Todėl jos naudojimas yra paprastas:

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

Tiesiog nenoriu pridėti func į String objektus, nes jiems priskiriamas el. Pašto adresas (ar ne). Taigi, kiek suprantu, „ Bool nuosavybė geriau tinka nei func .

1
15 мая '18 в 20:52 2018-05-15 20:52 Alejandro Iván atsakymas pateikiamas gegužės 15 d. 18 val. 20:52 2018-05-15 20:52

Swift 4.2“ ir „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") } 

Jei norite naudoti „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() { } } 

Ir skambinkite tokia funkcija.

 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
12 окт. Atsakymas pateiktas „ iOS Oct 12“. 2018-10-12 13:11 '18 - 01:11 pm 2018-10-12 13:11

Atrodo, kad jis veikia taip pat ...

 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 } 
1
10 июня '16 в 23:00 2016-06-10 23:00 atsakymą pateikė „ Logicopolis “ birželio 16 d. 16 val

„Basic NSRegularExpression“, „ Swift 3“ , pažiūrėkite patys naudodami „IBM Swift Sandbox“ nuorodą:

 let pattern = "[^@]+@[a-zA-Z0-9-.]+\\.[a-zA-Z]{2,}" var regex: NSRegularExpression? do { regex = try NSRegularExpression(pattern: pattern, options: []) } catch let error { print("regex failed for \(pattern), error \(error)") } let testEmail = "name@test.ca" let matches = regex!.matches(in: testEmail, options: .withTransparentBounds, range: NSMakeRange(0, testEmail.characters.count)) if matches.count != 0 { print("Email appears to be valid") } else { print("Email does not appear to be valid") } 

„IBM Sandbox“: „ Swift Base“ NSRegularExpression Email Verification

0
19 апр. atsakymą pateikė Rob 19 balandis 2017-04-19 03:01 '17 at 3:01 2017-04-19 03:01

Čia yra labai paprastas būdas, esantis dabartiniame „Swiftmailer“. Dauguma kitų atsakymų yra seni ir išrado ratą.

Pagal „Swiftmailer“ dokumentaciją: https://swiftmailer.symfony.com/docs/messages.html#quick-reference

 use Egulias\EmailValidator\EmailValidator; use Egulias\EmailValidator\Validation\RFCValidation; $validator = new EmailValidator(); $validator->isValid("example@example.com", new RFCValidation()); //true 

Tai yra pats lengviausias ir patikimiausias požiūris, TJO. Tiesiog įdiekite per „Composer the Egulias“ „EmailValidator“ biblioteką, kuri vis tiek turėtų būti įtraukta į „SwiftMailer“ priklausomybę.

0
23 янв. Atsakymą pateikė JaneDoe , sausio 23 d 2019-01-23 11:34 '19 , 11:34 am 2019-01-23 11:34

Mano vienintelis papildymas atsakymų sąraše būtų tas, kad „ NSRegularExpression “ nėra „Linux“, iš tikrųjų, 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 

Jis sėkmingai kaupia tiek „MacOS“, tiek „Ubuntu“.

0
24 окт. Andrei Popos atsakymas 24 okt. 2016-10-24 23:15 '16 at 11:15 pm 2016-10-24 23:15
Atsakymas

@JeffersonBe yra arti, bet grįžta true jei eilutė „kažkas su someone@something.com yra galiojantis el. Žemiau yra String plėtinys, kuris veikia gerai (ir leidžia jums patikrinti galiojantį telefono numerį ir kitus duomenų detektorius atsisiųsti.

 /// 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
18 сент. Gujamino atsakymas, rugsėjo 18 d 2016-09-18 05:40 '16 at 5:40 am 2016-09-18 05:40

Man patinka sukurti plėtinį

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

naudoti:

 if emailid.text!.isValidateEmail() == false(){ //do what ever you want if string is not matched. } 
0
15 мая '18 в 21:01 2018-05-15 21:01 atsakymą pateikė siva kumar gegužės 15-18 d. 21:01 2018-05-15 21:01

Geriausias sprendimas su geriausiais rezultatais

Swift 4.x

  extension String { func validateAsEmail() -> Bool { let emailRegEx = "(?:[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
11 мая '18 в 17:03 2018-05-11 17:03 Atsakymą pateikė Abdelahad Darwish , gegužės 11 d. 18 val. 17:03 2018-05-11 17:03
 //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% darbas ir testavimas

0
08 марта '18 в 12:24 2018-03-08 12:24 Atsakymą davė p. Javed Multani kovo 8 d. 18 val. 12:24 val. 2018-03-08 12:24

Atnaujintas @Arsonik atsakymas bus atsakas į „Swift 2.2“, naudojant mažiau išsamų kodą nei kiti siūlomi sprendimai:

 extension String { func isValidEmail() -> Bool { let regex = try? NSRegularExpression(pattern: "^[a-zA-Z0-9.!#$% options: .CaseInsensitive) return regex?.firstMatchInString(self, options: [], range: NSMakeRange(0, self.characters.count)) != nil } } 
0
10 авг. Matias Seijas atsakymas 10 rug. 2016-08-10 00:26 '16 at 0:26 2016-08-10 00:26

Kadangi šiuo metu yra tiek daug keistų aukščiausio lygio domenų vardų, aš nustojau tikrinti aukščiausio domeno ilgį ...

Štai ką aš naudoju:

 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
26 февр. atsakymas pateikiamas snieglenčių10 26 Vasario 26 d. 2016-02-26 08:12 '16 at 8:12 2016-02-26 08:12

Čia yra Swift 3 plėtinys

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

Tiesiog naudokite jį taip:

 if yourEmailString.isValidEmail() { //code for valid email address } else { //code for not valid email address } 
0
22 нояб. Gefilte Fish atsakymą pateikė lapkričio 22 d. 2017-11-22 18:14 '17, 18:14 pm 2017-11-22 18:14

Ir Swift 3 :

 extension String { func isValidEmail() -> Bool { let regex = try? NSRegularExpression(pattern: "^[a-zA-Z0-9.!#$% options: .caseInsensitive) return regex?.firstMatch(in: self, options: [], range: NSMakeRange(0, self.characters.count)) != nil } } 
0
14 окт. Atsakyti Danut Pralea 14 okt. 2016-10-14 17:06 '16 at 17:06 pm 2016-10-14 17:06

Aš pagerinau atsakymą @Azik. Pritariu daugiau specialių simbolių, kuriuos leidžiama naudoti pagal gaires, ir kai kuriuos papildomus ypatingus atvejus grąžina negaliojančiais.

Grupė mano, kad čia leidžiama tik ._%+- vietinėje dalyje tai nėra teisinga pagal gaires. Žr. Atsakymą @Anton Gogolev į šį klausimą arba žiūrėkite žemiau:

Vietinė el. Pašto adreso dalis gali naudoti bet kurį iš šių ASCII simbolių:

  • didžiosios ir mažosios lotyniškos abėcėlės raidės iki A Z ir iki z ;

  • numeriai nuo 0 iki 9 ;

  • specialūs simboliai !#$%> ;

  • taškas su sąlyga, kad tai nėra pirmasis ar paskutinis simbolis, nebent jis yra kabutėse, taip pat, jei jis nėra iš eilės, jei ne John..Doe@example.com kabučių (pvz., John..Doe@example.com neleidžiama, tačiau „ "John..Doe"@example.com “ leidžiama;

  • „ir "(),:;<>@[\] ), komentarai leidžiami

  • su skliausteliais bet kuriame vietinės dalies gale; pvz., (comment)john.smith@example.com ir (comment)john.smith@example.com lygiavertės (comment)john.smith@example.com ;

Naudojamas kodas neleidžia naudoti specialių simbolių, turinčių ribotą prieigą, bet suteikia daug daugiau funkcijų nei dauguma čia pateiktų atsakymų. Я бы предпочел более мягкую проверку ошибкам со стороны предостережения.

 if enteredText.contains("..") || enteredText.contains("@@") || enteredText.hasPrefix(".") || enteredText.hasSuffix(".con"){ return false } let emailFormat = "[A-Z0-9a-z.!#$% let emailPredicate = NSPredicate(format:"SELF MATCHES %@", emailFormat) return emailPredicate.evaluate(with: enteredText) 
0
ответ дан JavaBeast 03 июня '18 в 0:45 2018-06-03 00:45
  • 1
  • 2

Посмотрите другие вопросы по меткам или Задайте вопрос