在Swift中，我使用if let语句来检查我的对象是否不是nil
if let obj = optionalObj
{
}
但有时候，我不得不面对连续的 if let 声明。
if let obj = optionalObj
{
if let a = obj.a
{
if let b = a.b
{
// do stuff
}
}
}
我正在寻找一种避免连续使用 if let 声明的方法。
我会尝试这样做：
if let obj = optionalObj && if let a = obj.a && if let b = a.b
{
// do stuff
}
但是 Swift 编译器不允许这样做。
有什么建议吗？
在Swift 1.2中，您可以执行以下操作：
if let a = optA, let b = optB {
doStuff(a, b)
}
在你的特定情况下，你可以使用可选链：
if let b = optionaObj?.a?.b {
// do stuff
}
现在，如果您需要做的是：
if let a = optA {
if let b = optB {
doStuff(a, b)
}
}
你没那么幸运，因为你无法使用可选链。
你想要一句简洁的表达吗？
doStuff <^> optA <*> optB
请继续阅读。尽管看起来很可怕，但这实际上是非常强大的，并且使用起来并不像看起来那么疯狂。
幸运的是，这是一个可以轻松解决的问题，只需使用函数式编程方法即可。 您可以使用 Applicative 抽象，并提供一个apply方法来组合多个选项。
这里有一个例子，摘自http://robots.thoughtbot.com/functional-swift-for-dealing-with-optional-values
首先，我们需要一个函数，仅当可选值包含某些内容时才将函数应用于可选值
// this function is usually called fmap, and it's represented by a <$> operator
// in many functional languages, but <$> is not allowed by swift syntax, so we'll
// use <^> instead
infix operator <^> { associativity left }
func <^><A, B>(f: A -> B, a: A?) -> B? {
switch a {
case .Some(let x): return f(x)
case .None: return .None
}
}
然后我们可以使用 apply 将多个选项组合在一起，我们将其称为 <*>，因为我们很酷（而且我们懂一些 Haskell）
// <*> is the commonly-accepted symbol for apply
infix operator <*> { associativity left }
func <*><A, B>(f: (A -> B)?, a: A?) -> B? {
switch f {
case .Some(let value): return value <^> a
case .None: return .None
}
}
现在我们可以重新编写我们的例子。
doStuff <^> optA <*> optB
只要doStuff是柯里化形式的（见下文），这将起作用，即：
func doStuff(a: A)(b: B) -> C { ... }
整个事情的结果是一个可选值，可以是nil，也可以是doStuff的结果。以下是在playground中尝试的完整示例：
func sum(a: Int)(b: Int) -> Int { return a + b }
let optA: Int? = 1
let optB: Int? = nil
let optC: Int? = 2
sum <^> optA <*> optB // nil
sum <^> optA <*> optC // Some 3
作为最后的说明，将函数转换为其柯里化形式非常简单。例如，如果您有一个接受两个参数的函数：
func curry<A, B, C>(f: (A, B) -> C) -> A -> B -> C {
return { a in { b in f(a,b) } }
}
现在您可以使用柯里化(curry)任何两个参数的函数，比如说+
curry(+) <^> optA <*> optC // Some 3
every函数，我有点喜欢这种方法。func every<A, B>(a: A?, b: B?) -> (A, B)? {
switch (a, b) {
case let (.Some(a), .Some(b)): return .Some((a, b))
default: return .None
}
}
func every<A, B, C>(a: A?, b: B?, c: C?) -> (A, B, C)? {
switch (a, b, c) {
case let (.Some(a), .Some(b), .Some(c)): return .Some((a, b, c))
default: return .None
}
}
// and so on...
这些可以用在if let语句、case表达式以及 optional.map(...)链中：
// 1.
var foo: Foo?
if let (name, phone) = every(parsedName, parsedPhone) {
foo = ...
}
// 2.
switch every(parsedName, parsedPhone) {
case let (name, phone): foo = ...
default: foo = nil
}
// 3.
foo = every(parsedName, parsedPhone).map{name, phone in ...}
为了添加每个every的重载，会很繁琐但只需要在库中完成一次。同样地，使用应用函子方法（即使用<^> 和 <*>操作符）时，您需要以某种方式创建柯里化函数，这也会在某些地方导致一些样板代码。
every方法？ - Jean Lebrumentevery2是liftA2（，），every3是liftA3（，，，）。 - CodaFievery实现可以建立在我的答案之上。一旦我们有了Applicative机制，剩下的就只是巧妙的语法了 ;) - Gabriele Petronellaif let b = optionalObj?.a?.b {
// do stuff
}
if optionalObj?.a?.b != nil {
let obj = optionalObj!
let a = obj.a!
let b = a.b!
}
在听了Martin R的一些讲座之后，我发现了一个有趣的解决方法：https://dev59.com/iGAf5IYBdhLWcg3wgzHI#26012746
func unwrap<T, U>(a:T?, b:U?, handler:((T, U) -> ())?) -> Bool {
switch (a, b) {
case let (.Some(a), .Some(b)):
if handler != nil {
handler!(a, b)
}
return true
default:
return false
}
}
extension Array
{
func find(includedElement: T -> Bool) -> Int?
{
for (idx, element) in enumerate(self)
{
if includedElement(element)
{
return idx
}
}
return nil
}
}
func unwrap<T>(handler:((T...) -> Void)?, a:T?...) -> Bool
{
let b : [T!] = a.map { $0 ?? nil}
if b.find({ $0 == nil }) == nil
{
handler(b)
}
}
无法将表达式的类型 '[T!]' 转换为类型 '((T...) -> Void)?'
有什么解决方法建议吗？
if let块，但我不太喜欢它。 - Craig Otis