ios - address - valid email swift 4

¿Cómo validar una dirección de correo electrónico en swift?

Question

¿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.

Answer 1

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 de expresiones regulares que a menudo se ven 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., lo 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 una enorme cantidad de usuarios

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

Explicación:

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

__firstpart ... tiene que comenzar y terminar con un OC. Para los caracteres en el medio puede tener algunos caracteres inusuales como el guión bajo, pero el comienzo y el final deben ser OC. (Está bien tener solo un OC y eso es todo, ejemplo [email protected])

__servidor ... Tienes secciones como "bla". que se repiten. (Por lo tanto, tipo de cosa mail.city.fcu.edu). Las secciones deben comenzar y terminar con un OC, pero en el medio también puede tener un guión "-". (Si desea permitir otros caracteres inusuales allí, diga el guión bajo, solo agréguelo antes del guión). Está bien tener una sección que sea solo un OC. (Como en [email protected] o [email protected]) 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 construirlo siempre. Esto es lo primero que menciona Apple sobre el tema en el doco.

Answer 2

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

Answer 3

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 correo electrónico según RFC 5322, tenga en cuenta que es mejor no usarlo porque solo comprueba la sintaxis básica de las direcciones de correo electrónico y no comprueba 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 el correo electrónico RegExs.

Tenga en cuenta que no se puede escapar como lo requiere un lenguaje como Objective-C o Swift.

Answer 4

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
}

Answer 5

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

}

Answer 6

Crear simple extensión:

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:

"[email protected]".isValidEmail //true
"b@bb".isValidEmail //false

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

Answer 7

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.

Answer 8

En Swift 4.2 y Xcode 10

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

Si quieres usar 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() {

}
}

Y llamar a una función como esta ....

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

Answer 9

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

Answer 10

Esta es una nueva versión para "THE RAZONABLE SOLUTION" 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 = "[email protected]"
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 una func a los objetos String , ya que ser una dirección de correo electrónico es inherente a ellos (o no). Así que una propiedad de Bool encajaría mejor que una func , desde mi entendimiento.

Answer 11

Hay muchas respuestas correctas aquí, pero muchas de las "expresiones regulares" están incompletas y puede suceder que un correo electrónico como: "nombre @ dominio" resulte 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
        }
    }
}

Answer 12

Hice una biblioteca diseñada para validaciones de entrada y uno de los "módulos" te 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: "[email protected]")) {
   //email is valid
}

SwiftCop es la biblioteca ... espero que te ayude!

Answer 13

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

Answer 14

La respuesta de @ JeffersonBe está cerca, pero devuelve true si la cadena es "algo que contiene a [email protected] 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 probar el número de teléfono válido y otros detectores de datos para iniciar.

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

Answer 15

Me gusta crear extension

   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.

}

Answer 16

Mejoré la respuesta de @Azik. Permito más caracteres especiales permitidos por las directrices, así como devolver algunos casos adicionales como no válidos.

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

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

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

• dígitos del 0 al 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, [email protected] no está permitido pero "John..Doe"@example.com está permitido);

• el espacio y los caracteres "(),:;<>@[/] están permitidos con restricciones (solo se permiten dentro de una cadena entre comillas, como se describe en el párrafo a continuación, y además, una barra invertida o una comilla doble deben ir precedidas 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)[email protected] son equivalentes a [email protected] ;

El código que utilizo 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)

Answer 17

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 compila exitosamente tanto en macOS como en Ubuntu.

Answer 18

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

Answer 19

Parece que funciona también ...

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
}

Answer 20

Prefiero usar una extensión para eso. Además, esta url http://emailregex.com puede ayudarlo a comprobar si la expresión regular es correcta. De hecho, el sitio ofrece diferentes implementaciones para algunos lenguajes de programació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)
    }
}

Answer 21

Respuesta actualizada @Arsonik responde a Swift 2.2, usando 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
    }
}

Answer 22

Si está buscando una solución limpia y sencilla para hacer esto, debe consultar 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 = "[email protected]"
let rule = EmailValidationPredicate()
let isValidEmail = rule.evaluate(with: email)

Detrás del capó utiliza el registro RFC 5322 ( 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])+)//])"

Answer 23

Uso de Swift 4.

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

Y usado

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

    }

Answer 24

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

Answer 25

Ya que hay tantos nombres de dominio de nivel superior raros ahora, dejo de verificar la longitud del dominio superior ...

Esto es lo que yo 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)
    } 
}

Answer 26

Yo sugeriría usarlo como una extensión de String:

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

Y para usarlo:

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

Answer 27

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

Answer 28

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

Answer 29

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

Ejemplo a continuación: importar UIKit importar FormValidationKit

clase 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<String>, 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__)
}

Enlace Github aquí

Answer 30

//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% funcionando y probado.