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

题

苹果的文档指定：

首次初始化属性时，不会调用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
    }
}

我创建了method doStuff，以使处理调用更简洁，但我只想处理didSet函数中的属性。有没有办法在初始化过程中强制此调用？

更新资料

我决定只为我的类删除便捷的初始化器，并强迫您在初始化后设置属性。这使我知道didSet将永远被调用。我还不确定总体上是否更好，但这很适合我的情况。

创建一个自己的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为type ：（AnyObject!一个隐式解包的可选），可以让self完全初始化而无需 someProperty设置。打电话时， setSomeProperty(someProperty)您叫的等价物 self.setSomeProperty(someProperty)。通常，您将无法执行此操作，因为self尚未完全初始化。由于 someProperty不需要初始化，并且您正在调用依赖于self的方法，因此Swift会离开初始化上下文，并且didSet将运行。

如果您使用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

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

class Classy {

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

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

}

编辑：布莱恩·韦斯特法尔的答案是更好的恕我直言。关于他的好处是，它暗示了这个意图。

我有同样的问题，这对我有用

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

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

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

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

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确实关心

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

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

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

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

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

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

您可以通过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
    }
}