如果你在初始化式中使用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

如果你在初始化式中使用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

如果你在子类中这样做，这是可行的

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()

在本例中，没有触发didSet。但是在b的例子中，didSet被触发了，因为它在子类中。它必须处理初始化上下文的真正含义，在这种情况下，超类确实关心这个

在特定的情况下，你想在init中调用willSet或didSet来获取父类中可用的属性，你可以简单地直接分配你的父属性:

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
    }
}

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

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

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