¿Cómo validar una dirección de correo electrónico rápidamente?

¿Alguien sabe cómo validar una dirección de correo electrónico en Swift? Encontré este código:

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

pero no puedo traducirlo a Swift.

Yo usaría 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) } 

para las versiones de Swift anteriores a 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) } 

para versiones de Swift anteriores a 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 } 

Edición, actualizada para 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) } 

Respuesta original para 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) } 

Está funcionando bien.

Como una extensión de clase 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 } } 

Uso

 if "rdfsdsfsdfsd".isValidEmail() { } 

Si está buscando una solución limpia y simple para hacer esto, debería echar un vistazo a https://github.com/nsagora/validation-components .

Contiene un predicado de validación de correo electrónico que es fácil de integrar en su código:

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

Detrás del capó usa el 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])+)\\])" 

Aquí hay un fusible de las dos respuestas más votadas con la expresión regular correcta: una extensión de cadena que usa predicado para que pueda llamar a 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) } } 

Esta es la versión actualizada de 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 } } 

Aquí está la solución razonable:

“LA SOLUCIÓN RAZONABLE”

Usado y probado durante años en muchas, muchas aplicaciones de gran volumen.

1 – evita los muchos errores muy regex que a menudo ve en estas sugerencias

2 – no permite correos electrónicos estúpidos como “x @ x” que son técnicamente válidos, pero son completamente estúpidos, y su personal de soporte, etc., rechazaría instantáneamente de todos modos. Si necesita (¿con qué propósito?) Una solución que permita correos electrónicos estúpidos, use otra solución.

3 – es extremadamente comprensible , tanto como se puede esperar

4 – Es KISS, confiable y probado para su destrucción en aplicaciones comerciales con un gran número de usuarios

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

Explicación:

En la siguiente descripción, “OC” significa carácter ordinario: entonces, una letra o un dígito.

__firstpart … tiene que comenzar y terminar con un OC. Para los personajes en el medio, puede tener algunos caracteres inusuales, como subrayado, pero el inicio y el final deben ser OC. (Está bien tener solo un OC, eso es todo, ejemplo j@blah.com)

__serverpart … Tienes secciones como “blah”. que se repite (Entonces, el tipo de cosa mail.city.fcu.edu.) Las secciones tienen que comenzar y terminar con un OC, pero en el medio también puede tener el guión “-“. (Si desea permitir que entren otros caracteres inusuales, diga subrayado, simplemente agréguela antes del guión). Está bien tener una sección que sea solo un OC. (Como en joe@x.com o joe@w.campus.edu) Puede tener hasta cinco secciones; tienes que tener uno. Finalmente, el TLD (.com o similar) es estrictamente de 2 a 8 letras.

Tenga en cuenta que simplemente mantiene el predicado como global (trivial en Swift), sin necesidad de comstackrlo cada vez. Esto es lo primero que Apple menciona sobre el problema en el doco.

Sugeriría usarlo como una extensión de String:

 extension String { public var isEmail: Bool { let dataDetector = try? NSDataDetector(types: NSTextCheckingResult.CheckingType.link.rawValue) let firstMatch = dataDetector?.firstMatch(in: self, options: NSRegularExpression.MatchingOptions.reportCompletion, range: NSRange(location: 0, length: length)) return (firstMatch?.range.location != NSNotFound && firstMatch?.url?.scheme == "mailto") } public var length: Int { return self.characters.count } } 

Y para usarlo:

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

Aquí hay un método basado en 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 } 

Nota: longitud de TLD actualizada.

Aquí está el RegEx definitivo para el correo electrónico según RFC 5322, tenga en cuenta que esto no se usa porque solo verifica la syntax básica de las direcciones de correo electrónico y no verifica si existe el dominio de nivel superior.

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

Consulte Regular-Expressions.info para obtener información más completa sobre RegExs de correo electrónico.

Tenga en cuenta que no se escapa, tal como lo requiere un lenguaje como Objective-C o Swift.

Prefiero usar una extensión para eso. Además, esta url http://emailregex.com puede ayudarte a probar si la expresión regular es correcta. De hecho, el sitio ofrece diferentes implementaciones para algunos lenguajes de progtwigción. Comparto mi implementación para Swift 3 .

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

Aquí hay muchas respuestas correctas, pero muchas de las “expresiones regulares” están incompletas y puede suceder que un correo electrónico como: “nombre @ dominio” genere un correo electrónico válido, pero no lo es. Aquí la solución completa:

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

Para swift 2.1: esto funciona correctamente con el correo electrónico 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 } } } 

Hice una biblioteca diseñada para validaciones de entrada y uno de los “módulos” le permite validar fácilmente un montón de cosas …

Por ejemplo, para validar un correo electrónico:

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

SwiftCop es la biblioteca … ¡espero que ayude!

Crear una extensión simple:

 extension NSRegularExpression { convenience init(pattern: String) { try! self.init(pattern: pattern, options: []) } } extension String { var isValidEmail: Bool { return isMatching(expression: NSRegularExpression(pattern: "^[A-Z0-9a-z\\._%+-]+@([A-Za-z0-9-]+\\.)+[A-Za-z]{2,4}$")) } //MARK: - Private private func isMatching(expression: NSRegularExpression) -> Bool { return expression.numberOfMatches(in: self, range: NSRange(location: 0, length: characters.count)) > 0 } } 

Ejemplo:

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

Puede extender la siguiente extensión a todo lo que necesite: isValidPhoneNumber , isValidPassword , etc.

Parece que también funciona …

 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 } 

Esta es una nueva versión de “LA SOLUCIÓN RAZONABLE” de @Fattie, probada en Swift 4.1 en un nuevo archivo llamado 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) } } 

Entonces su uso es simple:

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

Simplemente no me gusta agregar un func a los objetos String , ya que una dirección de correo electrónico es inherente a ellos (o no). Así que una propiedad Bool cabría mejor que un func , desde mi punto de vista.

Dado que ahora hay tantos nombres de dominio extraños, dejo de verificar la longitud del dominio superior …

Esto es lo que uso:

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

Respuesta actualizada @Arsonik responde a Swift 2.2, utilizando un código menos detallado que otras soluciones ofrecidas:

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

La respuesta de @JeffersonBe está cerca, pero devuelve true si la cadena es “algo que contiene alguien@something.com un correo electrónico válido” que no es lo que queremos. La siguiente es una extensión en String que funciona bien (y permite la prueba de numberNumber válido y otros detectores de datos para arrancar.

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

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

Mi única adición a la lista de respuestas sería que para Linux, NSRegularExpression no existe, en realidad es 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 

Esto comstack con éxito tanto en macOS como en Ubuntu.

Aquí hay una extensión en 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) } } 

Solo úsalo así:

 if yourEmailString.isValidEmail() { //code for valid email address } else { //code for not valid email address } 
 //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% trabajando y probando

La mejor solución con el mejor resultado para

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

Me gusta crear una extensión

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

uso:

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

Mejoré la respuesta @Azik. Permito más caracteres especiales que están permitidos por las directrices, y también devuelvo algunos casos de bordes adicionales como no válidos.

El grupo piensa que continuar aquí solo permite ._%+- en la parte local no es correcto según las pautas. Vea la respuesta de @Anton Gogolev sobre esta pregunta o vea a continuación:

La parte local de la dirección de correo electrónico puede usar cualquiera de estos caracteres ASCII:

  • letras latinas mayúsculas y minúsculas de la A a la Z y de la a a la z ;

  • dígitos 0 a 9 ;

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

  • punto , siempre que no sea el primer o el último carácter a menos que se indique, y siempre que no aparezca consecutivamente a menos que se indique (por ejemplo, John..Doe@example.com no está permitido, pero "John..Doe"@example.com es permitido);

  • espacio y los caracteres "(),:;<>@[\] están permitidos con restricciones (solo se permiten dentro de una cadena entrecomillada, como se describe en el párrafo siguiente, y además, una barra invertida o una comilla doble debe ir precedida por una barra invertida); se permiten comentarios

  • con paréntesis en cada extremo de la parte local; por ejemplo, john.smith(comment)@example.com y (comment)john.smith@example.com son ambos equivalentes a john.smith@example.com ;

El código que uso no permitirá caracteres especiales restringidos fuera de lugar, pero permitirá muchas más opciones que la mayoría de las respuestas aquí. Preferiría una validación más relajada al error por el lado de la precaución.

 if enteredText.contains("..") || enteredText.contains("@@") || enteredText.hasPrefix(".") || enteredText.hasSuffix(".con"){ return false } let emailFormat = "[A-Z0-9a-z.!#$%&'*+-/=?^_`{|}~]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,64}" let emailPredicate = NSPredicate(format:"SELF MATCHES %@", emailFormat) return emailPredicate.evaluate(with: enteredText) 

Puede encontrar un marco de validación de formulario reutilizable útil. Lo ha creado reglas de campo y crea crear sus reglas de validación personalizadas implementando el protocolo FieldValidator.

Ejemplo a continuación: importar importación de UIKit FormValidationKit

class ViewController: UIViewController, FormValidationDelegate, FieldValidatorDelegate {var formValidator: FormValidator?

 var usernameValidator : FieldValidator? var emailValidator : FieldValidator? @IBOutlet weak var usernameTf: UITextField! @IBOutlet weak var emailTf: UITextField! @IBAction func didTapButton(sender: AnyObject) { formValidator?.submit() } override func viewDidLoad() { super.viewDidLoad() //Initialize the form validator formValidator = FormValidator() //Create field validators //Set nil to first field validator usernameValidator = FieldValidator(inputValue: { () -> AnyObject in return self.usernameTf.text }, rules: [Required(validationError: ValidationError(hint: "Field is required"))], nextValidator: nil, form: formValidator!) usernameValidator!.delegate = self emailValidator = FieldValidator(inputValue: { () -> AnyObject in return self.emailTf.text }, rules: [Email(validationError: ValidationError(hint: "Proper email format"))], nextValidator: usernameValidator!, form: formValidator!) emailValidator!.delegate = self formValidator?.initialValidator = emailValidator! formValidator?.delegate = self } //per field error delegate method func didEvaluateField(field: FieldValidator, errors: Array, form: FormValidator) { switch field { case usernameValidator!: println("Username field error") break; case emailValidator!: println("Username field error") default: println("Field error") } } //form delegate methods func didPassFormValidation(form: FormValidation) { println(__FUNCTION__) } func didFailFormValidation(form: FormValidation) { println(__FUNCTION__) } 

Github enlace aquí

O puede tener una extensión para el texto opcional de UITextField:

cómo utilizar:

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

extensión:

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

Perfect Regex como Google Email

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