Call can throw, but it is not marked with 'try' and the error is not handled: NSRegularExpression

I have written this function in String Extension and can’t figure out the error.

func isEmail() -> Bool {
    let regex = NSRegularExpression(pattern: "^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,4}$", options: [.CaseInsensitive])

    return regex.firstMatchInString(self, options: nil, range: NSMakeRange(0, characters.count)) != nil
}

The error is:

  • Handling Errors in New Firebase and Swift
  • Easy SpriteKit Contact Detection (Space Shooter Game) Not Wotking Properly
  • Crash when open containing app from today extension
  • How to draw a line in the simplest way in swift
  • multipart PUT request using AFNetworking
  • Creating an extension to filter nils from an Array in Swift
  • Call can throw, but it is not marked with ‘try’ and the error is not handled

    4 Solutions Collect From Internet About “Call can throw, but it is not marked with 'try' and the error is not handled: NSRegularExpression”

    NSRegularExpression(pattern:) throws an error if the pattern is invalid. In your case, the pattern is fixed, so an invalid pattern
    would be a programming error.

    This is a use-case for the “forced-try” expression with try!:

    extension String {
        func isEmail() -> Bool {
            let regex = try! NSRegularExpression(pattern: "^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,4}$",
                options: [.CaseInsensitive])
    
            return regex.firstMatchInString(self, options:[],
                range: NSMakeRange(0, utf16.count)) != nil
        }
    }
    

    try! disables the error propagation so that the method does not
    throw an error (which the caller has to catch). It will abort with a
    runtime exception if the pattern is invalid, which helps to find
    programming errors early.

    Note also that NSRange() counts the length of NSString, i.e. the number of UTF-16 code points, so
    characters.count should be utf16.count, otherwise it might crash
    e.g. with Emoji characters.

    That’s because that initializer can now throw an exception, so you need to try to call it and be prepared to catch the exception. You can do this by adding try before the initializer and annotating your method with throws.

    extension String {
        func isEmail() throws -> Bool {
            let regex = try NSRegularExpression(pattern: "^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,4}$", options: [.CaseInsensitive])
    
            return regex.firstMatchInString(self, options: NSMatchingOptions(rawValue: 0), range: NSMakeRange(0, characters.count)) != nil
        }
    }
    

    Then when you want to call the method, do it from within a do block and catch the error that comes out.

    do {
        try "person@email.com".isEmail()
    } catch {
        print(error)
    }
    

    Note: I’ve also updated your regex.firstMatchInString call to reflect the fact that the options parameter can no longer take a nil value.

    If you don’t like try catch :

    extension String {
        func matchPattern(patStr:String)->Bool {
                var isMatch:Bool = false
                do {
                    let regex = try NSRegularExpression(pattern: patStr, options: [.CaseInsensitive])
                    let result = regex.firstMatchInString(self, options: NSMatchingOptions(rawValue: 0), range: NSMakeRange(0, characters.count))
    
                    if (result != nil)
                    {
                        isMatch = true
                    }
                }
                catch {
                    isMatch = false
                }
                return isMatch
        }
    }    
    

    check string is correct email format :

    let emailInput:String = "checkthis@gmail.com"
    if (emailInput.matchPattern("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,4}$")==true)
    {
         print("this is e-mail!")
    }
    

    You could use string.rangeOfString, and specify the option to .RegularExpressionSearch. It’s simple.

    func isEmail(email: String) -> Bool {
        return email.rangeOfString("^[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,6}$", options: .RegularExpressionSearch) != nil
    }