不幸的是，根类初始化时不会调用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并执行:

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

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

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

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

注意:你需要让你的属性为空，或者为它们设置一个默认值，或者打开类属性。

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

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被触发了，因为它在子类中。它必须处理初始化上下文的真正含义，在这种情况下，超类确实关心这个

不幸的是，根类初始化时不会调用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并执行:

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

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

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

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

注意:你需要让你的属性为空，或者为它们设置一个默认值，或者打开类属性。

我也有同样的问题，这个方法对我很有效

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

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

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

创建一个自己的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
    }
}

By declaring someProperty as type: AnyObject! (an implicitly unwrapped optional), you allow self to fully initialize without someProperty being set. When you call setSomeProperty(someProperty) you're calling an equivalent of self.setSomeProperty(someProperty). Normally you wouldn't be able to do this because self hasn't been fully initialized. Since someProperty doesn't require initialization and you are calling a method dependent on self, Swift leaves the initialization context and didSet will run.

作为Oliver回答的一种变体，您可以将这些行包装成闭包。例如:

class Classy {

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

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

}

编辑:Brian Westphal的回答更好。这句话的好处是暗示了他的意图。