Optional hell in Swift? - swift

Question

How can I properly handle optionals especially when it is multi-level optional?
For example,
let html = String(data: response.data!, encoding: .utf8)
if let string = html {
let doc = try? SwiftSoup.parse(html)
let links = try? doc?.select("a").array().map{try? $0.attr("href")}
}
// links!![0]! is crazy
Constant links is like below: optional of optional array of optional strings
Optional(Optional([Optional("abc.com"), Optional("def.com")]))
Is there a pattern which is more proper than do-try-catch block or optional binding?

Answer 1

Replace most of the try? with try in a do/catch. You only need one do/catch with your multiple try. Use if let more. Use flatMap instead of map.
if let html = String(data: response.data!, encoding: .utf8) {
do {
let doc = try SwiftSoup.parse(html)
let links = try doc.select("a").array().flatMap { try? $0.attr("href") }
} catch {
// Uh-oh
}
}
I can't test this so this may not be perfect but it should get you most of the way there.

Answer 2

You can chain several if let statements in a single command, like this:
if let string = html, let doc = try? SwiftSoup.parse(html) {
...
}

Answer 3

You've got several choices, none of which are really more "proper" than the others, so it's a matter of taste. But I'd probably do one of:
A compound if statement:
if let responseData = response.data,
let string = String(data: responseData, encoding: .utf8),
let doc = try? SwiftSoup.parse(html),
let links = try? doc.select("a").array().compactMap({ try? $0.attr("href") }) {
// do something with links, any nil will get filtered out from the array
// (if using earlier than Swift 4.1, use flatMap instead of compactMap)
}
guard statements:
guard let responseData = response.data else { /* bail somehow */ }
guard let string = String(data: responseData, encoding: .utf8) else { /* bail somehow */ }
... etc ...
Alternately, one long guard statement written like the if statement above.
Or, y'know, just use a good old-fashioned do/try/catch block.