是否可以允许在 Swift 初始化期间调用 didSet？

Question

问题

Apple's docs 指定：

第一次初始化属性时不会调用 willSet 和 didSet 观察者。仅当属性的值在初始化上下文之外设置时才会调用它们。

是否可以在初始化期间强制调用这些？

为什么？

假设我有这门课

class SomeClass {
    var someProperty: AnyObject {
        didSet {
            doStuff()
        }
    }

    init(someProperty: AnyObject) {
        self.someProperty = someProperty
        doStuff()
    }

    func doStuff() {
        // do stuff now that someProperty is set
    }
}

我创建了方法doStuff，以使处理调用更简洁，但我宁愿只处理didSet 函数中的属性。有没有办法在初始化期间强制它调用？

更新

我决定只删除我的类的便利初始化程序，并强制您在初始化后设置属性。这让我知道didSet 将始终被调用。我还没有决定这是否总体上更好，但它很适合我的情况。

Answer 1

如果您在 initializer 中使用defer，用于更新任何可选属性或进一步更新您已经初始化并且在调用任何super.init() 方法之后的非可选属性，那么你的willSet、didSet等就会被调用。我发现这比实现必须跟踪在正确位置调用的单独方法更方便。

例如：

public class MyNewType: NSObject {

    public var myRequiredField:Int

    public var myOptionalField:Float? {
        willSet {
            if let newValue = newValue {
                print("I'm going to change to \(newValue)")
            }
        }
        didSet {
            if let myOptionalField = self.myOptionalField {
                print("Now I'm \(myOptionalField)")
            }
        }
    }

    override public init() {
        self.myRequiredField = 1

        super.init()

        // Non-defered
        self.myOptionalField = 6.28

        // Defered
        defer {
            self.myOptionalField = 3.14
        }
    }
}

将产生：

I'm going to change to 3.14
Now I'm 3.14

Answer 2

创建一个自己的 set-Method 并在您的 init-Method 中使用它：

class SomeClass {
    var someProperty: AnyObject! {
        didSet {
            //do some Stuff
        }
    }

    init(someProperty: AnyObject) {
        setSomeProperty(someProperty)
    }

    func setSomeProperty(newValue:AnyObject) {
        self.someProperty = newValue
    }
}

通过将someProperty 声明为类型：AnyObject!（隐式 未包装的可选），您允许 self 完全初始化而无需 someProperty 正在设置中。你打电话的时候 setSomeProperty(someProperty) 你正在调用相当于 self.setSomeProperty(someProperty)。通常你将无法 这样做是因为 self 尚未完全初始化。自从 someProperty 不需要初始化，您正在调用 方法依赖于自身，Swift 离开初始化上下文并 didSet 将运行。

Answer 3

作为 Oliver 答案的变体，您可以将这些行包装在一个闭包中。例如：

class Classy {

    var foo: Int! { didSet { doStuff() } }

    init( foo: Int ) {
        // closure invokes didSet
        ({ self.foo = foo })()
    }

}

编辑：Brian Westphal 的回答更好恕我直言。关于他的好处是它暗示了意图。

Answer 4

我遇到了同样的问题，这对我有用

class SomeClass {
    var someProperty: AnyObject {
        didSet {
            doStuff()
        }
    }

    init(someProperty: AnyObject) {
        defer { self.someProperty = someProperty }
    }

    func doStuff() {
        // do stuff now that someProperty is set
    }
}

Answer 5

如果您在子类中执行此操作，则此方法有效

class Base {

  var someProperty: AnyObject {
    didSet {
      doStuff()
    }
  }

  required init() {
    someProperty = "hello"
  }

  func doStuff() {
    print(someProperty)
  }
}

class SomeClass: Base {

  required init() {
    super.init()

    someProperty = "hello"
  }
}

let a = Base()
let b = SomeClass()

在a 示例中，didSet 未被触发。但在b 示例中，didSet 被触发，因为它在子类中。它必须与 initialization context 的真正含义有关，在这种情况下，superclass 确实关心这一点

Answer 6

虽然这不是一个解决方案，但另一种解决方法是使用类构造函数：

class SomeClass {
    var someProperty: AnyObject {
        didSet {
            // do stuff
        }
    }

    class func createInstance(someProperty: AnyObject) -> SomeClass {
        let instance = SomeClass() 
        instance.someProperty = someProperty
        return instance
    }  
}

Answer 7

在特定情况下，如果您想在 init 内为超类中可用的属性调用 willSet 或 didSet，您可以直接分配您的超属性：

override init(frame: CGRect) {
    super.init(frame: frame)
    // this will call `willSet` and `didSet`
    someProperty = super.someProperty
}

请注意，带有闭包的Charlesism 解决方案在这种情况下也始终有效。所以我的解决方案只是一个替代方案。

Answer 8

不幸的是，在初始化根类时不会调用 didSet 观察者。

如果你的类不是子类，你必须使用 getter 和 setter 来实现你想要的功能：

class SomeClass {
    private var _test: Int = 0
    var test: Int {
        get { _test }
        set { _test = newValue }
    }
    
    init(test: Int) { self.test = test }
}

或者，如果你的类是子类，你可以使用 didSet 和 do：

override init(test: int) {
    super.init()
    self.test = test
}

应该在调用 super.init() 之后调用 didSet。

一件事我没有尝试过，但也可能有用：

init(test: int) {
    defer { self.test = test }
}

注意：您需要使您的属性可以为空，或者为它们设置一个默认值，或者解开类属性。

Answer 9

你可以用obj-с方式解决：

class SomeClass {
    private var _someProperty: AnyObject!
    var someProperty: AnyObject{
        get{
            return _someProperty
        }
        set{
            _someProperty = newValue
            doStuff()
        }
    }
    init(someProperty: AnyObject) {
        self.someProperty = someProperty
        doStuff()
    }

    func doStuff() {
        // do stuff now that someProperty is set
    }
}