ios - swift open mail




Come convalidare un indirizzo e-mail in swift? (17)

È possibile trovare utile un framework di convalida del modulo riutilizzabile. Ha creato regole di campo e tu crei le tue regole di convalida personalizzate implementando il protocollo FieldValidator.

Esempio di seguito: import UIKit import 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<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__)
}

Link Github qui

Qualcuno sa come convalidare un indirizzo e-mail in Swift? Ho trovato questo codice:

- (BOOL) validEmail:(NSString*) emailString {

    if([emailString length]==0){
        return NO;
    }

    NSString *regExPattern = @"[A-Z0-9a-z._%+-][email protected][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;
    }
}

ma non posso tradurlo in Swift.


@ La risposta di JeffersonBe è vicina, ma restituisce true se la stringa è "qualcosa contenente [email protected] un'email valida" che non è ciò che vogliamo. Quanto segue è un'estensione su String che funziona bene (e consente di eseguire il test per phoneNumber validi e altri rilevatori di dati per l'avvio.

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

Come estensione di una classe 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.!#$%&'*+/=?^_`{|}~-][email protected][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() {

}

Crea un'estensione semplice:

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\\._%+-][email protected]([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
    }
}

Esempio:

"[email protected]".isValidEmail //true
"[email protected]".isValidEmail //false

Puoi estendere l'estensione seguente a qualsiasi cosa tu abbia bisogno: isValidPhoneNumber , isValidPassword etc ...


E per Swift 3 :

extension String {
    func isValidEmail() -> Bool {
        let regex = try? NSRegularExpression(pattern: "^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-][email protected][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
    }
}

Ecco la soluzione ragionevole:

"LA SOLUZIONE RAGIONEVOLE"

1 - evita i molti errori di regex che vedi spesso in questi suggerimenti

2 - non consente email stupide come "x @ x" che sono tecnicamente valide, ma sono completamente stupide - e il personale di supporto, ecc., Rifiuterebbe comunque in ogni caso. Se hai bisogno (per quale scopo?) Di una soluzione che permetta email stupide, usa un'altra soluzione.

3 - è estremamente comprensibile , per quanto si possa sperare

4 - È BACIO, affidabile e testato per la distruzione su app commerciali con un numero enorme di utenti

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,6}"
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
    }
}

Spiegazione:

Nella seguente descrizione, "OC" significa carattere ordinario: quindi, una lettera o una cifra.

__firstpart ... deve iniziare e finire con un OC. Per i personaggi nel mezzo puoi avere alcuni caratteri insoliti come il trattino basso, ma l'inizio e la fine devono essere OC. (Va bene avere solo un OC e basta, esempio [email protected])

__serverpart ... Hai sezioni come "blah". quale ripetizione. (Quindi, mail.city.fcu.edu tipo di cosa.) Le sezioni devono iniziare e finire con un OC, ma nel mezzo si può anche avere un trattino "-". (Se si desidera consentire ad altri caratteri insoliti in là, ad esempio sottolineatura, è sufficiente aggiungerlo prima del trattino.) È OK avere una sezione che è solo un OC. (Come in [email protected] o [email protected]) È possibile avere fino a cinque sezioni; devi averne uno Infine il TLD (.com o simili) è strettamente composto da 2 a 6 lettere.

Nota che tieni semplicemente il predicato come globale (banale in Swift), non c'è bisogno di costruirlo ogni volta.


Ecco un'estensione in Swift 3

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

Basta usarlo in questo modo:

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

Ecco una combinazione delle due risposte più votate con la regex corretta: un'estensione di stringa che utilizza il predicato in modo da poter chiamare string.isEmail

    extension String {
        var isEmail: Bool {
           let emailRegEx = "[A-Z0-9a-z._%+-][email protected][A-Za-z0-9.-]+\\.[A-Za-z]{2,20}"            
           let emailTest  = NSPredicate(format:"SELF MATCHES %@", emailRegEx)
           return emailTest.evaluateWithObject(self)
        }
    }

La mia unica aggiunta all'elenco delle risposte sarebbe che per Linux, NSRegularExpression non esiste, in realtà è RegularExpression

    func isEmail() -> Bool {

    let patternNormal = "[A-Z0-9a-z._%+-][email protected][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

Questo compila con successo sia su macOS che su Ubuntu.


Modifica, aggiornata per Swift 3:

func validateEmail(enteredEmail:String) -> Bool {

    let emailFormat = "[A-Z0-9a-z._%+-][email protected][A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"
    let emailPredicate = NSPredicate(format:"SELF MATCHES %@", emailFormat)
    return emailPredicate.evaluate(with: enteredEmail)

}

Risposta originale per Swift 2:

func validateEmail(enteredEmail:String) -> Bool {

    let emailFormat = "[A-Z0-9a-z._%+-][email protected][A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"
    let emailPredicate = NSPredicate(format:"SELF MATCHES %@", emailFormat)
    return emailPredicate.evaluateWithObject(enteredEmail)

}

Funziona bene.


Per swift 2.1: funziona correttamente con email foo @ bar

extension String {
    func isValidEmail() -> Bool {
        do {
            let regex = try NSRegularExpression(pattern: "[A-Z0-9a-z._%+-][email protected][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
        }
    }
}

Preferisco usare un'estensione per questo. Inoltre, questo url http://emailregex.com può aiutarti a verificare se la regex è corretta. In effetti, il sito offre diverse implementazioni per alcuni linguaggi di programmazione. Condivido la mia implementazione per Swift 3 .

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

Risposta aggiornata @Arsonik risponde a Swift 2.2, utilizzando un codice meno dettagliato rispetto ad altre soluzioni offerte:

extension String {
    func isValidEmail() -> Bool {
        let regex = try? NSRegularExpression(pattern: "^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-][email protected][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
    }
}

Se stai cercando una soluzione semplice e pulita per farlo, dovresti dare un'occhiata a https://github.com/nsagora/validation-components .

Contiene un predicato di convalida della posta elettronica che è facile da integrare nel codice:

let email = "[email protected]"
let rule = EmailValidationPredicate()
let isValidEmail = rule.evaluate(with: email)

Dietro il cofano utilizza 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])+)\\])"

Suggerirei di usarlo come un'estensione di String:

extension String {    
    public var isEmail: Bool {
        let dataDetector = try? NSDataDetector(types: NSTextCheckingType.Link.rawValue)
        let firstMatch = dataDetector?.firstMatchInString(self, options: NSMatchingOptions.ReportCompletion, range: NSRange(location: 0, length: length))
        return (firstMatch?.range.location != NSNotFound && firstMatch?.URL?.scheme == "mailto")
    }

    public var length: Int {
        return self.characters.count
    }
}

E per usarlo:

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

Fonte: https://github.com/goktugyil/EZSwiftExtensions/blob/master/Sources/StringExtensions.swift


Vorrei usare NSPredicate :

 func isValidEmail(testStr:String) -> Bool {        
    let emailRegEx = "[A-Z0-9a-z._%+-][email protected][A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"

    let emailTest = NSPredicate(format:"SELF MATCHES %@", emailRegEx)
    return emailTest.evaluate(with: testStr)
}

per le versioni di Swift precedenti alla 3.0:

 func isValidEmail(testStr:String) -> Bool {
    // print("validate calendar: \(testStr)")
    let emailRegEx = "[A-Z0-9a-z._%+-][email protected][A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"

    let emailTest = NSPredicate(format:"SELF MATCHES %@", emailRegEx)
    return emailTest.evaluate(with: testStr)
}

per le versioni di Swift precedenti alla 1.2:

 class func isValidEmail(testStr:String) -> Bool {
    println("validate calendar: \(testStr)")
    let emailRegEx = "[A-Z0-9a-z._%+-][email protected][A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"

    if let emailTest = NSPredicate(format:"SELF MATCHES %@", emailRegEx) {
        return emailTest.evaluateWithObject(testStr)
    }
    return false
}

//Email validation
func validateEmail(enterEmail:String) -> Bool{
    let emailFormat = "[A-Z0-9a-z._%+-][email protected][A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"
    let emailPredicate = NSPredicate(format:"SELF MATCHES %@",emailFormat)
    return emailPredicate.evaluate(with:enterEmail)
}

100% funzionante e testato







swift