将 UIButton 连接到关闭？ （迅速，目标行动）

Question

我想将 UIButton 连接到一段代码 - 根据我的发现，在 Swift 中执行此操作的首选方法仍然是使用 addTarget(target: AnyObject?, action: Selector, forControlEvents: UIControlEvents) 函数。这使用 Selector 构造大概是为了与 Obj-C 库向后兼容。我想我理解 Obj-C 中 @selector 的原因——能够引用方法，因为在 Obj-C 中方法不是一等值。

不过，在 Swift 中，函数是一等值。有没有办法将 UIButton 连接到闭包，类似于：

// -- Some code here that sets up an object X

let buttonForObjectX = UIButton() 

// -- configure properties here of the button in regards to object
// -- for example title

buttonForObjectX.addAction(action: {() in 

  // this button is bound to object X, so do stuff relevant to X

}, forControlEvents: UIControlEvents.TouchUpOutside)

据我所知，上述情况目前是不可能的。考虑到 Swift 看起来它的目标是变得非常实用，这是为什么呢？这两个选项显然可以共存以实现向后兼容性。为什么这不像 JS 中的 onClick() 那样工作？似乎唯一将 UIButton 连接到目标-动作对的方法是使用仅出于向后兼容性原因而存在的东西 (Selector)。

我的用例是在循环中为不同的对象创建 UIButton，然后将每个对象连接到一个闭包。 （设置标签/在字典中查找/子类化 UIButton 是肮脏的半解决方案，但我对如何在功能上做到这一点感兴趣，即这种关闭方法）

Answer 1

UIButton 继承自 UIControl，它处理输入的接收和转发到选择。根据文档，该操作是“识别操作消息的选择器。它不能为 NULL。” Selector 严格来说是一个指向方法的指针。

我认为鉴于 Swift 似乎将重点放在闭包上，这是可能的，但情况似乎并非如此。

Answer 2

您可以使用代理类来处理此问题，该代理类通过目标/动作（选择器）机制将事件路由到您制作的闭包。我已经为手势识别器做到了这一点，但同样的模式应该适用于控件。

你可以这样做：

import UIKit

@objc class ClosureDispatch {
    init(f:()->()) { self.action = f }
    func execute() -> () { action() }
    let action: () -> ()
}

var redBlueGreen:[String] = ["Red", "Blue", "Green"]
let buttons:[UIButton] = map(0..<redBlueGreen.count) { i in
    let text = redBlueGreen[i]
    var btn = UIButton(frame: CGRect(x: i * 50, y: 0, width: 100, height: 44))
    btn.setTitle(text, forState: .Normal)
    btn.setTitleColor(UIColor.redColor(), forState: .Normal)
    btn.backgroundColor = UIColor.lightGrayColor()
    return btn
}

let functors:[ClosureDispatch] = map(buttons) { btn in
    let functor = ClosureDispatch(f:{ [unowned btn] in
        println("Hello from \(btn.titleLabel!.text!)") })
    btn.addTarget(functor, action: "execute", forControlEvents: .TouchUpInside)
    return functor
}

对此的一个警告是，由于 addTarget:... 不保留目标，因此您需要保留调度对象（与仿函数数组一样）。当然，您不必严格地按住按钮，因为您可以通过闭包中捕获的引用来做到这一点，但您可能需要显式引用。

PS。我试图在操场上对此进行测试，但无法让 sendActionsForControlEvents 工作。不过，我已经将这种方法用于手势识别器。

Answer 3

对于您认为应该在库中但不在库中的任何内容，一般方法是：编写一个类别。 GitHub 上有很多这种特殊的，但在 Swift 中没有找到，所以我自己写了一个：

=== 把这个放到自己的文件里，比如 UIButton+Block.swift ===

import ObjectiveC

var ActionBlockKey: UInt8 = 0

// a type for our action block closure
typealias BlockButtonActionBlock = (sender: UIButton) -> Void

class ActionBlockWrapper : NSObject {
    var block : BlockButtonActionBlock
    init(block: BlockButtonActionBlock) {
        self.block = block
    }
}

extension UIButton {
    func block_setAction(block: BlockButtonActionBlock) {
        objc_setAssociatedObject(self, &ActionBlockKey, ActionBlockWrapper(block: block), objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        addTarget(self, action: "block_handleAction:", forControlEvents: .TouchUpInside)
    }

    func block_handleAction(sender: UIButton) {
        let wrapper = objc_getAssociatedObject(self, &ActionBlockKey) as! ActionBlockWrapper
        wrapper.block(sender: sender)
    }
}

然后像这样调用它：

myButton.block_setAction { sender in
    // if you're referencing self, use [unowned self] above to prevent
    // a retain cycle

    // your code here

}

显然，这可以改进，可以有各种活动的选项（不仅仅是内部修饰）等等。但这对我有用。 它比纯 ObjC 版本稍微复杂一些，因为需要一个块的包装器。 Swift 编译器不允许将块存储为“AnyObject”。所以我把它包起来了。

Answer 4

这不一定是“挂钩”，但您可以通过继承 UIButton 有效地实现此行为：

class ActionButton: UIButton {
    var touchDown: ((button: UIButton) -> ())?
    var touchExit: ((button: UIButton) -> ())?
    var touchUp: ((button: UIButton) -> ())?

    required init?(coder aDecoder: NSCoder) { fatalError("init(coder:)") }
    override init(frame: CGRect) {
        super.init(frame: frame)
        setupButton()
    }

    func setupButton() {
        //this is my most common setup, but you can customize to your liking
        addTarget(self, action: #selector(touchDown(_:)), forControlEvents: [.TouchDown, .TouchDragEnter])
        addTarget(self, action: #selector(touchExit(_:)), forControlEvents: [.TouchCancel, .TouchDragExit])
        addTarget(self, action: #selector(touchUp(_:)), forControlEvents: [.TouchUpInside])
    }

    //actions
    func touchDown(sender: UIButton) {
        touchDown?(button: sender)
    }

    func touchExit(sender: UIButton) {
        touchExit?(button: sender)
    }

    func touchUp(sender: UIButton) {
        touchUp?(button: sender)
    }
}

用途：

let button = ActionButton(frame: buttonRect)
button.touchDown = { button in
    print("Touch Down")
}
button.touchExit = { button in
    print("Touch Exit")
}
button.touchUp = { button in
    print("Touch Up")
}

Answer 5

根据n13's solution，我做了一个swift3版本。

希望它能帮助像我这样的人。

import Foundation
import UIKit
import ObjectiveC

var ActionBlockKey: UInt8 = 0

// a type for our action block closure
typealias BlockButtonActionBlock = (_ sender: UIButton) -> Void

class ActionBlockWrapper : NSObject {
    var block : BlockButtonActionBlock
    init(block: @escaping BlockButtonActionBlock) {
        self.block = block
    }
}

extension UIButton {
    func block_setAction(block: @escaping BlockButtonActionBlock, for control: UIControlEvents) {
        objc_setAssociatedObject(self, &ActionBlockKey, ActionBlockWrapper(block: block), objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        self.addTarget(self, action: #selector(UIButton.block_handleAction), for: .touchUpInside)
    }

    func block_handleAction(sender: UIButton, for control:UIControlEvents) {

        let wrapper = objc_getAssociatedObject(self, &ActionBlockKey) as! ActionBlockWrapper
        wrapper.block(sender)
    }
}

Answer 6

使用RxSwift很容易解决这个问题

import RxSwift
import RxCocoa

...

@IBOutlet weak var button:UIButton!

...

let taps = button.rx.tap.asDriver() 

taps.drive(onNext: {
    // handle tap
})

---

编辑：

我想承认 RxSwift/RxCocoa 是一个非常重量级的依赖项，添加到项目中只是为了解决这个需求。可能有更轻量级的解决方案可用，或者只是坚持目标/行动模式。

无论如何，如果您对处理应用程序和用户事件的通用声明式方法的想法有吸引力，那么一定要看看 RxSwift。这是炸弹。

Answer 7

ObjectiveC 的关联对象和包装、指针和导入是不必要的，至少在 Swift 3 中是这样。这很好用，而且更加 Swift-y。如果您觉得 () -> () 更具可读性，请随意在其中添加类型别名，我发现直接读取块签名更容易。

import UIKit

class BlockButton: UIButton {
    fileprivate var onAction: (() -> ())?

    func addClosure(_ closure: @escaping () -> (), for control: UIControlEvents) {
        self.addTarget(self, action: #selector(actionHandler), for: control)
        self.onAction = closure
    }

    dynamic fileprivate func actionHandler() {
        onAction?()
    }
} 

Answer 8

您可以通过添加一个辅助闭包包装器 (ClosureSleeve) 并将其作为关联对象添加到控件中以使其保留，从而将 target-action 替换为闭包。

这与 n13 的答案中的解决方案类似。但我发现它更简单、更优雅。更直接地调用闭包并自动保留包装器（作为关联对象添加）。

斯威夫特 3 和 4

class ClosureSleeve {
    let closure: () -> ()

    init(attachTo: AnyObject, closure: @escaping () -> ()) {
        self.closure = closure
        objc_setAssociatedObject(attachTo, "[\(arc4random())]", self, .OBJC_ASSOCIATION_RETAIN)
    }

    @objc func invoke() {
        closure()
    }
}

extension UIControl {
    func addAction(for controlEvents: UIControlEvents = .primaryActionTriggered, action: @escaping () -> ()) {
        let sleeve = ClosureSleeve(attachTo: self, closure: action)
        addTarget(sleeve, action: #selector(ClosureSleeve.invoke), for: controlEvents)
    }
}

用法：

button.addAction {
    print("Hello")
}

它会自动挂钩到.primaryActionTriggered 事件，该事件等于 UIButton 的.touchUpInside。