Swift 函数作为类中的参数

Question

我是一个快速的初学者，所以要温柔......

我在将函数分配为参数时遇到问题。

我已经定义了这个结构：

struct dispatchItem {
   let description: String
   let f: ()->Void

   init(description: String, f: @escaping ()->()) {
      self.description = description
      self.f = f
   }
}

我在一个名为 MasterDispatchController 的类中使用它，如下所示：

class MasterDispatchController: UITableViewController {

   let dispatchItems = [
      dispatchItem(description: "Static Table", f: testStaticTable),
      dispatchItem(description: "Editable Table", f: testEditableTable)
   ]

    func testEditableTable() {
        //some code
    }

    func testStaticTable() {
        //some code
    }

等等

然后我的代码中有一个表格视图，它分派给单击的任何函数（我在上面的代码中显示的不仅仅是两个，但这并不重要）就像这样

   override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
      dispatchItems[indexPath.row].f()
   }

所以...编译器对此并不满意。它说当我定义 dispatchItems let 语句时：

无法将类型 '(MasterDispatchController) -> () -> ()' 的值转换为预期的参数类型 '() -> ()'

我想......好吧......我不确定我是否完全理解这一点，但编译器似乎想知道回调函数将来自哪个类。我明白为什么它可能需要它。所以我有点盲目地遵循编译器给我的模式，并将我的结构更改为：

struct dispatchItem {
   let description: String
   let f: (MasterDispatchController)->()->Void

   init(description: String, f: @escaping (MasterDispatchController)->()->()) {
      self.description = description
      self.f = f
   }
}

编译器很高兴，但现在当我尝试使用 dispatchItems[indexPath.row].f() 调用该函数时，它会说：

调用中缺少参数#1

该函数没有参数，所以我很困惑......

我想也许它是在向我询问有问题的对象的实例，这会有些意义......在我的例子中这将是“自我”，所以我尝试了dispatchItems[indexPath.row].f(self)，但后来我得到了一个错误：

表达式解析为未使用的函数

所以我有点卡住了。

对不起，如果这是一个愚蠢的问题。感谢您的帮助。

Answer 1

问题是您试图在实例属性的初始化程序中引用实例方法testStaticTable 和testEditableTable之前 self 完全初始化。因此，编译器不能部分应用这些以self 作为隐式参数的方法，而是只能使用offer you the curried versions - 类型为(MasterDispatchController) -> () -> ()。

然后可能会想将dispatchItems 属性标记为lazy，以便属性初始化程序在属性的第一次访问 上运行，而self 是 完全初始化。

class MasterDispatchController : UITableViewController {

    lazy private(set) var dispatchItems: [DispatchItem] = [
        DispatchItem(description: "Static Table", f: self.testStaticTable),
        DispatchItem(description: "Editable Table", f: self.testEditableTable)
    ]

    // ...
}

^{（请注意，我重命名了您的结构以符合 Swift 命名约定）}

现在编译，因为您现在可以引用方法的部分应用版本（即 () -> Void 类型），并且可以将它们称为：

dispatchItems[indexPath.row].f()

然而，您现在有一个保留周期，因为您将闭包存储在 self 上，这些闭包会强烈捕获 self。这是因为当用作值时，self.someInstanceMethod 解析为部分应用的闭包，该闭包强烈捕获self。

您已经接近实现的一个解决方案是使用方法的 curried 版本 - 不要强烈捕获 self，而是必须应用于给定实例以进行操作。

struct DispatchItem<Target> {

    let description: String
    let f: (Target) -> () -> Void

    init(description: String, f: @escaping (Target) -> () -> Void) {
        self.description = description
        self.f = f
    }
}

class MasterDispatchController : UITableViewController {

    let dispatchItems = [
        DispatchItem(description: "Static Table", f: testStaticTable),
        DispatchItem(description: "Editable Table", f: testEditableTable)
    ]

    override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        dispatchItems[indexPath.row].f(self)()
    }

    func testEditableTable() {}
    func testStaticTable() {}
}

这些函数现在将MasterDispatchController 的给定实例作为参数，并为您返回正确的实例方法来调用该给定实例。因此，您需要先用self 应用它们，通过说f(self) 来调用实例方法，然后用() 调用结果函数。

尽管使用self 经常应用这些功能可能会很不方便（或者您甚至可能无法访问self）。更通用的解决方案是将self 存储为weak 属性在DispatchItem 上，以及咖喱函数——然后您可以“按需”应用它：

struct DispatchItem<Target : AnyObject> {

    let description: String

    private let _action: (Target) -> () -> Void
    weak var target: Target?

    init(description: String, target: Target, action: @escaping (Target) -> () -> Void) {
        self.description = description
        self._action = action
    }

    func action() {
        // if we still have a reference to the target (it hasn't been deallocated),
        // get the reference, and pass it into _action, giving us the instance
        // method to call, which we then do with ().
        if let target = target {
            _action(target)()
        }
    }
}

class MasterDispatchController : UITableViewController {

    // note that we've made the property lazy again so we can access 'self' when
    // the property is first accessed, after it has been fully initialised.
    lazy private(set) var dispatchItems: [DispatchItem<MasterDispatchController>] = [
        DispatchItem(description: "Static Table", target: self, action: testStaticTable),
        DispatchItem(description: "Editable Table", target: self, action: testEditableTable)
    ]

    override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        dispatchItems[indexPath.row].action()
    }

    func testEditableTable() {}
    func testStaticTable() {}
}

这确保您没有保留周期，因为DispatchItem 没有对self 的强引用。

当然，您可以使用unowned 对self 的引用，例如in this Q&A。但是，只有当您能够保证您的 DispatchItem 实例不会比 self 寿命长（您希望将 dispatchItems 设为 private 属性）时，您才应该这样做。

Answer 2

这里的问题是 Swift 在底层对待类方法和函数的方式不同。类方法获得一个隐藏的self 参数（类似于它在 Python 中的工作方式），这使它们能够知道在哪个类实例上调用了它们。这就是为什么即使您将testEditableCode 声明为() -> ()，实际函数的类型为(MasterDispatchController) -> () -> ()。它需要知道在哪个对象实例上调用了它。

正确的方法是创建一个调用正确方法的闭包，如下所示：

class MasterDispatchController: UITableViewController {

   let dispatchItems = [
      dispatchItem(description: "Static Table", f: {() in
        self.testStaticTable()
      }),
      dispatchItem(description: "Editable Table", f: {() in
        self.testEditableTable()
      })
   ]

    func testEditableTable() {
        //some code
    }

    func testStaticTable() {
        //some code
    }

如果您熟悉 JavaScript，{() in ...code...} 表示法与 Python 中的 function() { ...code... } 或 lambda: ...code... 相同。

Answer 3

这是实现你想要的方法。

用你想要的参数实现协议：

protocol Testable {
    func perfromAction()
    var description: String { get set }
    weak var viewController: YourViewController? { get set } //lets assume it is fine for testing
}

像这样访问您的UIViewController 并不完全正确，但现在还可以。您可以访问标签、segue 等。

为您想要的每个测试创建Class：

class TestA: Testable {
    var description: String
    weak var viewController: YourViewController?
    func perfromAction() {
        print(description) //do something
        viewController?.testCallback(description: description) //accessing your UIViewController
    }
    init(viewController: YourViewController, description: String) {
        self.viewController = viewController
        self.description = description
    }
}

class TestB: Testable {
    var description: String
    weak var viewController: YourViewController?
    func perfromAction() {
        print(description) //do something
        viewController?.testCallback(description: description) //accessing your UIViewController
    }
    init(viewController: YourViewController, description: String) {
        self.viewController = viewController
        self.description = description
    }
}

您可以为每个Class 添加一些自定义参数，但协议中的这 3 个参数是必需的。

那么你的UIViewController 会是这样的

class YourViewController: UIViewController {
    var arrayOfTest: [Testable] = []

    override func viewDidLoad() {
        super.viewDidLoad()
        arrayOfTest.append(TestA(viewController: self, description: "testA"))
        arrayOfTest.append(TestB(viewController: self, description: "testB"))
        arrayOfTest[0].perfromAction()
        arrayOfTest[1].perfromAction()
    }

    func testCallback(description: String) {
        print("I am called from \(description)")
    }
}