2 
let arr: [Int?] = [1,2,3,4,nil]

let arr1 = arr.flatMap { next in
    next
}
// arr1: [1,2,3,4]
let arr2: [Int?] = arr.flatMap { next -> Int? in
   next
}
// arr2: [Optional(1), Optional(2), Optional(3), Optional(4)]

我对这些代码感到困惑，为什么它们会有所作为？

更新：请看这些代码，我

let arr: [Int?] = [1,2,3,4,nil]

let arr1: [Int?] = arr.flatMap { next in
    next
}
// arr1: [Optional(1), Optional(2), Optional(3), Optional(4), nil]
let arr2: [Int?] = arr.flatMap { next -> Int? in
    next
}
// arr2: [Optional(1), Optional(2), Optional(3), Optional(4)]
4

2 回答 2

4

正如@Adam 所说，这是由于您为结果提供的显式类型。在您的第二个示例中，这会导致由双重包装的选项引起的混乱。为了更好地理解问题，让我们看一下flatMap函数签名。

@warn_unused_result
public func flatMap<T>(@noescape transform: (Self.Generator.Element) throws -> T?) rethrows -> [T]

当你明确指定结果是 type[Int?]时，因为flatMap返回泛型类型[T]- Swift 将推断T为 be Int?。

现在这会引起混乱，因为您传递给的闭包flatMap接受元素 input 并返回T?。因为Tis Int?，这个闭包现在将返回T??（双重包装的可选）。这编译得很好，因为类型可以自由地提升为可选项，包括可选项被提升为双选项。

所以发生的事情是Int?数组中的元素被提升为Int??元素，然后flatMap将它们解包回Int?. 这意味着元素在被双重包装时nil无法从您的元素中过滤掉，并且仅在包装的第二层上运行。arr1flatMap

为什么arr2 能够nil过滤掉它似乎是由于你传递给闭包flatMap的提升。因为你显式地将闭包的返回类型注释为 be Int?，所以闭包将被隐式提升 from (Element) -> Int?to (Element) -> Int??（闭包返回类型可以像其他类型一样自由提升）——而不是元素本身被提升为Int?to Int??，因为没有闭包的类型注释将被推断为(Element) -> Int??.

这个怪癖似乎允许nil避免被双重包装，因此允许flatMap将其过滤掉（不完全确定这是否是预期的行为）。

您可以在下面的示例中看到此行为：

func optionalIntArrayWithElement(closure: () -> Int??) -> [Int?] {
    let c = closure() // of type Int??
    if let c = c { // of type Int?
        return [c]
    } else {
        return []
    }
}

// another quirk: if you don't explicitly define the type of the optional (i.e write 'nil'),
// then nil won't get double wrapped in either circumstance
let elementA : () -> Int? = {Optional<Int>.None} // () -> Int?
let elementB : () -> Int?? = {Optional<Int>.None} // () -> Int??

// (1) nil gets picked up by the if let, as the closure gets implicitly upcast from () -> Int? to () -> Int??
let arr = optionalIntArrayWithElement(elementA)

// (2) nil doesn't get picked up by the if let as the element itself gets promoted to a double wrapped optional
let arr2 = optionalIntArrayWithElement(elementB)

if arr.isEmpty {
    print("nil was filtered out of arr") // this prints
}

if arr2.isEmpty {
    print("nil was filtered out of arr2") // this doesn't print
}

故事的道德启示

远离双重包装的选项，它们会给你带来超级混乱的行为！

如果您正在使用flatMap，那么[Int]如果您通过[Int?]. 如果要保留元素的可选性，请map改用。

于 2016-05-29T11:16:26.160 回答
1

它与您给出的显式类型有关arr2。当你指定它arr2必须是 type[Int?]时，Swift 会遵守并简单地将值包装在一个可选项中。但是，该flatMap操作返回数组的非 nil 值，这使得为什么arr1是 type很明显[Int]。要查看flatMap返回数组的非零值，只需查看函数的声明注释。此外，如果您了解该flatMap操作的一般用途，即它解开值的内部包装，您就会明白为什么该函数返回一个 type 的值[Int]。考虑arr，它是类型[Int?]。重写arr其包装形式的类型，它变为Array<Optional<Int>>. 为了flatMap要解开内部包装的函数，该函数必须返回一个 type 的值Array<Int>。为此，该函数必须抛出 nil 值。

于 2016-05-29T03:25:22.340 回答