Swift 1.2中可选展开中的Map和平面图差异

Question

地图和平面地图的定义都是隐含的，但根据文档，它们的定义（显然）不同：

Func地图（f：@noscape（T）-

如果self==nil，则返回nil。否则，返回f（self！）。

Func平面地图（f：@noscape（T）-

返回f（self）！iff self和f（self）不是零。

我试着用一个简单的例子来使用它们：

let number: Int? = 1

let res1 = number.map { $0 + 1 }.map { $0 + 1 }
let res2 = number.flatMap { $0 + 1 }.flatMap { $0 + 1 }

res1 //3
res2 //3

但即使数字为零，它们也产生了相同的结果 map或flatMap应用于ImplicitlyUnwrappedOptional，它们之间的实际区别是什么？我应该选择哪一个，何时选择？




Answer 1

flatMap解析嵌套选项，而map不解析嵌套选项。

平面图

var temp: Int? = 3
var flag: Bool = false
print(temp.flatMap { $0 < 5 ? 1 : nil } ?? .zero) 

// output: 1

地图

var temp: Int? = 3
var flag: Bool = false
print(temp.map { $0 < 5 ? 1 : nil } ?? .zero) 

// output: Optional(Optional(1))

Answer 2

这在映射闭包具有签名（T）的映射中是不可能的-

这不太正确。在我看来，Martin R的答案并没有完全触及问题的核心，那就是文档没有正确描述地图和平面地图之间的区别。

区别不在于他们采取什么样的收尾方式。每个人都会乐于接受一个生成非可选的闭包或一个生成可选的闭包——不管文档怎么说，也不管它们的声明有什么不同。所有这些表达式都可以编译：

let i : Int? = nil
let result1 = i.map {_ in "hello"} // map, closure produces nonOptional
let result2 = i.flatMap {_ in "hello"} // flatMap, closure produces nonOptional
let result3 = i.map {_ in Optional("hello") } // map, closure produces Optional
let result4 = i.flatMap {_ in Optional("hello") } // flatMap, closure produces Optional

好吧，那么实际的区别是什么？这是当闭包确实生成可选对象时，flatMap所做的：它将其展开，从而防止出现双重包装的可选对象：

let i : Int? = nil
let result1 = i.map {_ in "hello"} // String?
let result2 = i.flatMap {_ in "hello"} // String?
let result3 = i.map {_ in Optional("hello") } // String?? // double-wrapped
let result4 = i.flatMap {_ in Optional("hello") } // String? // not double-wrapped

这是map和flatMap之间的唯一区别。

Answer 3

（备注：答案已更新，以反映Swift 3及更高版本中的语法变化，例如取消了隐式附加（ImplicitlyUnwrappedOptional））

Optional.map（）和Optional.flatMap（）声明如下（我省略了这里不相关的throws/rethrows修饰符）：

func map<U>(_ transform: (Wrapped) -> U) -> U?
func flatMap<U>(_ transform: (Wrapped) -> U?) -> U?

让我们考虑使用“map”的第一个示例的简化版本：

let number: Int? = 1
let res1 = number.map { $0 + 1 }
print(res1) // Optional(2)

number具有Int？类型，闭包类型推断为（Int）-

现在，我们考虑第二个示例的简化版本“flatMap”：

let number: Int? = 1
let res2 = number.flatMap { $0 + 1 }
print(res2) // Optional(2)

flatMap需要类型为的闭包（已包装）-

let res2 = number.flatMap { return Optional($0 + 1) }

现在闭包的类型为（Int）-

因此，这些调用之间确实没有区别：

let res1 = number.map { $0 + 1 }
let res2 = number.flatMap { $0 + 1 }

然而，这并不是flatMap的本意。更现实的例子是

func foo(_ s : String?) -> Int? {
    return s.flatMap { Int($0) }
}

print(foo("1")) // Optional(1)
print(foo("x")) // nil (because `Int($0)` returns nil)
print(foo(nil)) // nil (because the argument is nil)

通常，map采用类型为的闭包（已包装）-

Optional<Wrapped>.none          --> Optional<U>.none
Optional<Wrapped>.some(wrapped) --> Optional<U>.some(transform(wrapped))

平面图采用类型的闭包（包装）-

Optional<Wrapped>.none          --> Optional<U>.none
Optional<Wrapped>.some(wrapped) --> transform(wrapped)

此处可以选择变换（包裹）

如果（如您的示例所示）使用不返回可选值的闭包调用了flatMap，那么编译器会自动将其转换为可选值，与映射没有任何区别。