Question

我有一个方法的协议。我认为方法可以用相同名称的闭包替换，但它似乎不起作用：

protocol Foo {
    func bar() // Type:  Void -> Void
}

class X: Foo {
    func bar() { }
}

class Y: Foo { // Compiler: doesn't conform to protocol Foo
    let bar: Void->Void = {}
}

有没有办法让这项工作？我想覆盖Test Stub实现的方法行为。目前，我必须这样做，我想缩短它：

class Z: Foo {
    var barClosure: Void -> Void = {}

    func bar() {
        barClosure()
    }
}

let baz = Z()
baz.barClosure = { /* ... */ }
baz.bar() // Calls the closure replacement

Answer 1

您声明协议有一个函数bar()，但在类Y中，您只有一个常量而不是函数，这就是问题。但是如果你想要在类Y中有类似的东西，你应该将协议改为：

protocol Foo {
    var bar: () -> () {get set}
}

并执行：

class Test: Foo {
    private var _bar: (() -> ())?

    var bar: () -> () {
        get {
            return {}
        }
        set {
            self._bar = newValue
        }
    }
}

<强>已更新

如果你缩短课程，可以使用类似的东西：

protocol Foo {
    var barClosure: Void -> Void {get set}
}

class Z: Foo {
    var barClosure: Void -> Void = {
        //do here something
    }
}

let a = Z()
a.barClosure()

Answer 2

感谢@DánielNagy，我能够弄清楚我有什么选择。该协议应该要求关闭。这样，客户端代码不会改变，因为闭包调用与方法调用相同。

使属性可变，因此实现可以决定是否要锁定值
仅需要吸气剂（出于同样的原因）
在生产代码中将属性初始化为不可变（let）
在测试代码中将属性初始化为可变（var）以在测试用例中提供替代实现，例如模拟观察者

这是一个修改过的示例，它通过返回字符串在Playground中运行良好：

protocol Foo {
    var bar: () -> String { get }
}

class X: Foo {
    // cannot be overwritten
    let bar: () -> String = { return "default x" }
}

class Y: Foo {
    private let _bar: () -> String = { return "default y" }

    // Can be overwritten but doesn't have any effect
    var bar: () -> String {
        get {
            return _bar
        }
        set {
        }
    }
}

class Z: Foo {
    // Can be overwidden
    var bar: () -> String = {
        return "default z"
    }
}

let bax = X()
bax.bar() // => "default x"
// bax.bar = { /* ... */ } // Forbidden

let bay = Y()
bay.bar() // => "default y"
bay.bar = { return "YY" }
bay.bar() // => "default y"

let baz = Z()
baz.bar() // => "default z"
baz.bar = { return "ZZ" }
baz.bar() // => "ZZ"

Answer 3

func关键字在幕后无法用属性进行复制 - 尤其是在类的情况下，函数可以被覆盖，因此需要构建vtable等等。 / p>

也就是说，如果你要使用闭包表达式替换方法，那么你需要做的不仅仅是你提供的代码。相当于：

struct A {
    let x: Int

    func f() {
        println("In f(), x is \(a.x)")
    }
}

更像是这样：

struct A {
    let x: Int

    // returns a function that takes A objects, and 
    // returns a function that captures them
    static let f: (A)->()->() = { a in 
      { ()->() in println("In f(), x is \(a.x)") } 
    }

    // equivalent of the dot notation call of f
    var f: ()->() {
        return A.f(self)
    }
}

这复制了struct方法的实际工作方式，并允许您执行f方法所做的所有事情：

let a = A(x: 5)

// static version of f
let A_f = A.f

// that static version bound to a self:
let f = A_f(a)
f()

// the above is equivalent to:
a.f()

但A仍然不足以符合需要f()方法的协议。

使用闭包属性满足Swift协议方法？

3 个答案: