Можно ли разрешить вызывать didSet во время инициализации в Swift?

Вопрос

Документы Apple указывают, что:

Наблюдатели 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функции. Есть ли способ заставить это вызвать во время инициализации?

Обновить

Я решил просто удалить удобство Intializer для моего класса и заставить вас установить свойство после инициализации. Это позволяет мне знать, didSetчто всегда будет называться. Я не решил, будет ли это лучше в целом, но это хорошо подходит для моей ситуации.

Создайте собственный метод set и используйте его в своем методе init:

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инициализация не требует инициализации, и вы вызываете метод, зависящий от себя, 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

Как вариант ответа Оливера, вы можете заключить строки в замыкание. Например:

class Classy {

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

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

}

Изменить: Брайан Вестфал ответ лучше imho. Приятно, что он намекает на намерения.

У меня была такая же проблема, и это работает для меня

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
}

Обратите внимание, что в этом случае тоже будет работать решение Шарлизма с замыканием. Так что мое решение - просто альтернатива.

Вы можете решить это в 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
    }
}