Returning String from a do-catch statement

Question

I was trying to translate the code from swift 2 to swift 4 and came across this error

Errors thrown from here are not handled

So I did this but now it tells me to return a string. Any idea how to do this?

func formatSentence(sentence:String) -> String
{
    do {
        let regex = try NSRegularExpression(pattern: "\\W+", options: .caseInsensitive)
        let modifiedString = regex.stringByReplacingMatches(in: sentence, options: [], range: NSRange(location: 0,length: sentence.count), withTemplate: "")

    } catch {
        print(error)
    }

    //I tried adding it here the return modifiedString but gives me error
}

This is what the original function looks like

func formatSentence(sentence:String) -> String
{
    let regex = NSRegularExpression(pattern: "\\W+", options: .caseInsensitive)//NSRegularExpression(pattern:"\\W+", options: .CaseInsensitive, error: nil)
    let modifiedString = regex.stringByReplacingMatches(in: sentence, options: [], range: NSRange(location: 0,length: sentence.count), withTemplate: "")

    return modifiedString
}

You might need to init the string like var response = "" outside of the do/catch and return it out side of it. You can then assign the response = modifiedString or response = error to return the error in case its throw. — antonioduarte, Jan 18 '18 at 02:52
@vadian yes, it says `Use of unresolved identifier 'modifiedString'` — , Jan 18 '18 at 02:53
what happens when u do this `return regex.stringByReplacingMatches(in: sentence, options: [], range: NSRange(location: 0,length: sentence.count), withTemplate: "")` — lionserdar, Jan 18 '18 at 02:53
remove the `let modifiedString` since you don't really need that — lionserdar, Jan 18 '18 at 02:54

Rob · Accepted Answer · 2019-09-16T08:55:33.207

It depends upon how you want to handle the error condition. There are a few options:

You could make it return String?, where nil means there was an error:

func formatSentence(_ sentence: String) -> String? {
    do {
        let regex = try NSRegularExpression(pattern: "\\W+", options: .caseInsensitive)
        let range = NSRange(sentence.startIndex..., in: sentence)
        return regex.stringByReplacingMatches(in: sentence, range: range, withTemplate: "")
    } catch {
        print(error)
        return nil
    }
}

And then you'd do something like:

guard let sentence = formatSentence(string) else { 
    // handle error here
    return
}

// use `sentence` here

You could define your function as one that throws the error if it encounters one:

func formatSentence(_ sentence: String) throws -> String {
    let regex = try NSRegularExpression(pattern: "\\W+", options: .caseInsensitive)
    let range = NSRange(sentence.startIndex..., in: sentence)
    return regex.stringByReplacingMatches(in: sentence, range: range, withTemplate: "")
}

And then you'd catch errors at the calling point:

do {
    let sentence = try formatSentence(string)

    // use `sentence` here
} catch {
    // handle error here
    print(error)
}

Or, given that you know your pattern is valid, you could use try! knowing that it cannot fail:

func formatSentence(_ sentence: String) -> String {
    let regex = try! NSRegularExpression(pattern: "\\W+", options: .caseInsensitive)
    let range = NSRange(sentence.startIndex..., in: sentence)
    return regex.stringByReplacingMatches(in: sentence, range: range, withTemplate: "")
}

And then you can just do:

let sentence = formatSentence(string)

You only use this last pattern if you know, with 100% confidence, that NSRegularExpression cannot fail given your regex pattern (such as in this situation).

As an aside, you might cut the Gordian knot and just use replacingOccurrences with .regularExpression option:

func formatSentence(_ sentence: String) -> String {
    return sentence.replacingOccurrences(of: "\\W+", with: "", options: .regularExpression)
}

When creating a `NSRange` you pass the `String` utf16 count `NSRange(location: 0,length: sentence.utf16.count)` or cast the `String` to `NSString` and pass its `length` — Leo Dabus, Jan 18 '18 at 06:19
Another option is to use the new Swift 4 initializer `init(_ region: R, in target: S) where R : RangeExpression, S : StringProtocol, R.Bound == String.Index, S.Index == String.Index` to convert from `Range` to `NSRange`: `NSRange(sentence.startIndex.. — Leo Dabus, Jan 18 '18 at 06:30
I was focused on the throwing `NSRegularExpression` and the returning of a string, but you are correct. I've updated my examples accordingly. Like I said at the end of my answer, he really should just use `replacingOccurrences(of:with:options:)`, and eliminate all of that silliness altogether. — Rob, Jan 18 '18 at 07:32

score -1 · Answer 2 · edited Jan 18 '18 at 03:24

-1

Set default values at the beginning of the function like so:

func formatSentence(sentence:String) -> String {
   var regex = ""
   var modifiedString = "" 

   do {
       regex = try NSRegularExpression(pattern: "\\W+", options: .caseInsensitive)
       modifiedString = regex.stringByReplacingMatches(in: sentence, options: [], range: NSRange(location: 0,length: sentence.count), withTemplate: "")

   } catch {
       print(error)
   }
   return modifiedString
}

edited Jan 18 '18 at 03:24

Rob

415,655
72
787
1,044

answered Jan 18 '18 at 03:00

Xcoder

1,433
3
17
37

The comment I posted at Rob’s answer applies here as well – Leo Dabus Jan 18 '18 at 06:25
Like the post below, this is a bad idea. Returning something valid from an error means that on the other end, you have to check if `modifiedString` is something other than empty and that gets unnecessarily complex – kakubei Jan 14 '19 at 15:22

Returning String from a do-catch statement

2 Answers2