swift - 结构的闭包属性可以在没有显式引用的情况下引用结构实例吗？

Question

这是我想做的，但是 quantity 属性不可用。

struct MyStruct {
    var quantity: Int
    let valueFn: () -> (Int)
}
var s1 = MyStruct(quantity: 2) { () -> (Int) in
    return quantity * 2 // error: can't use `quantity`
}

它也不适用于类:

class MyClass {
    var quantity: Int
    let valueFn: () -> (Int)

    init(valueFn: () -> (Int)) {
        self.valueFn = valueFn
    }
}
var c1 = MyClass { () -> (Int) in
    return quantity // error: can't use quantity or self
}

这个有效，但我必须显式传递 struct 或 struct 属性。 我的问题是:我可以在没有第三个属性包装和传递引用的情况下执行此操作吗？是否有更 Swifty 的方法？

struct MyOtherStruct {
    var quantity: Int
    private let valueFn: (Int) -> (Int)
    var value: Int {
        return valueFn(quantity)
    }
}
var s3 = MyOtherStruct(quantity: 2) { (quantity) -> (Int) in
    return quantity * 2
}
s3.value // -> 4

Answer 1

我在过去 20 分钟里一直在胡说八道，我认为这不可能在您的 MyStruct 实例的初始化 中实现；因为在对初始化程序的调用(您使用上面的尾随闭包执行的操作)中，实例 尚不存在。但是，我将在下面展示类(class)的解决方法；一种很像上面的第三种方法，一种具有更通用的用法(但类实现非常糟糕)，利用子类化 NSObject。

无论如何，关于直接与以一种通用的方式初始化。

---

下面是

1. 闭包“包装”方法是您的第三种解决方案:在初始化时发送的闭包上包装惰性闭包。这种方法的缺点是，对于不同的类实例，您无法选择要在闭包中使用哪些类属性，因为包装器(调用可变初始化闭包)已经在编译时设置。

2. 子类化 NSObject:一种对于任何实际使用来说可能都过于复杂的方法(而且相当不敏捷)，但是它可以让您更灵活地控制要在其中使用哪些类属性关闭。通过子类化 NSObject，您可以访问方法 .valueForKey 以应用于 self。为技术讨论/好奇添加。

方法一

class MyClass {
    var quantity: Int
    private let closure: (Int) -> (Int)

    init(quantity: Int, closure: (Int) -> (Int)) {
        self.quantity = quantity
        self.closure = closure
    }

    lazy var valueFn : () -> Int = {
        [unowned self] () -> Int in
        return self.closure(self.quantity)
    }
}

/* Example usage */
var c1 = MyClass(quantity: 2) { (a) -> (Int) in
    return a * 2
}

c1.valueFn() // 4
c1.quantity = 4
c1.valueFn() // 8

方法二

类设置(...):

class MyClass : NSObject {
    var quantity: Int = 0
    var anotherQuantity: Int = 0
    private var keyExists : Bool = true
    private let key : String
    private let foo: (Int) -> Int

    init(operateClosureOn: (propertyWithKey: String, withInitialValue: Int),
        closure: (Int) -> Int) {
        key = operateClosureOn.propertyWithKey
        foo = closure

        super.init()

        let val = operateClosureOn.withInitialValue
        if let _ = (Mirror(reflecting: self).children.filter{ $0.label == key }).first {
            self.setValue(val, forKey: key)
        }
        else { keyExists = false }
    }

    lazy var valueFn: () -> Int = {
        [unowned self] () -> Int in

        if !self.keyExists {
            return 0
        }

        guard let a = self.valueForKey(self.key) as? Int else {
            print("Unexpected: property for key '\(self.key)' is not if type 'Int'.")
            return 0
        }

        return self.foo(a)
    }
}

示例用法:

/* Example usage */
var c2 = MyClass(operateClosureOn: ("quantity", 2)) {
    (val) -> Int in
    return 2 * val
}

c2.valueFn() // 4
c2.quantity = 4
c2.valueFn() // 8

var c3 = MyClass(operateClosureOn: ("anotherQuantity", 20)) {
    (val) -> Int in
    return val / 2
}

c3.valueFn() // 10
c3.anotherQuantity = 40
c3.valueFn() // 20


var c4 = MyClass(operateClosureOn: ("aTypo", 20)) {
    (val) -> Int in
    return val / 2
}

c4.valueFn() // 0, OK, at least no runtime exception with this non-safe non-swifty solution :0)