Question

给出一个课程：

class First<T> {

}

第一类方法：

func second<U>(closure: (value: T) -> U) {

}

我如何将作为参数传递的闭包存储到second，以便我可以在以后调用它？

Answer 1

您需要在类中声明U，以便您拥有存储的类型：

class First<T,U> {
    var f : ((T) -> U)! = nil
    func second(closure: @escaping (T) -> U) {
        self.f = closure
    }
}

Answer 2

如果让second函数仅适用于某种类型，对你来说已经足够好了，那么马特的答案就是好的。

class First<T, U> {
    typealias ClosureType = (value: T) -> U
    var savedClosure: ClosureType? = nil
    func second(closure: ClosureType) {
        savedClosure = closure
    }
}

实际上没有按照规定回答你的问题！

事情是：您无法存储未知类型的值。 但！如果类型符合已知协议，则可以保存它。

protocol P {}

class First<T> {
    typealias ClosureType = (value: T) -> P
    var savedClosure: ClosureType? = nil
    func second<U: P>(closure: (value: T) -> U) {
        savedClosure = closure
    }
}

该协议甚至可以是protocol<>＆＃34;根本没有协议＆＃34;，其类型为关键字Any。

class First<T> {
    typealias ClosureType = (value: T) -> Any
    var savedClosure: ClosureType? = nil
    func second<U>(closure: (value: T) -> U) {
        savedClosure = closure
    }
}

但我们真的不知道你想做什么，所以你的问题有多个答案......例如，你想为每种类型存储一个单独的闭包吗？

class First<T> {
    typealias ClosureType = (value: T) -> Any
    var savedClosures = [String: ClosureType]()
    func second<U>(closure: (value: T) -> U) {
        savedClosures[String(U)] = closure
    }
}

无论如何，真正的问题是：＆＃34;你真的需要这样做吗？是否有一些简单的改变可以避免这种需要？＆＃34;

Swift泛型函数保存为可变

2 个答案: