Apakah mungkin untuk mengizinkan didSet dipanggil selama inisialisasi di Swift?

Pertanyaan

Dokumen Apple menetapkan bahwa:

pengamat willSet dan didSet tidak dipanggil saat properti pertama kali diinisialisasi. Mereka hanya dipanggil ketika nilai properti diatur di luar konteks inisialisasi.

Apakah mungkin untuk memaksa ini dipanggil saat inisialisasi?

Mengapa?

Katakanlah saya memiliki kelas ini

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

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

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

Saya menciptakan metode doStuff, untuk membuat panggilan pemrosesan lebih ringkas, tetapi saya lebih suka hanya memproses properti dalam didSetfungsi. Apakah ada cara untuk memaksa panggilan ini saat inisialisasi?

Memperbarui

Saya memutuskan untuk hanya menghapus intializer kenyamanan untuk kelas saya dan memaksa Anda untuk mengatur properti setelah inisialisasi. Ini memungkinkan saya untuk tahu didSetakan selalu dipanggil. Saya belum memutuskan apakah ini secara keseluruhan lebih baik, tapi itu cocok dengan situasi saya dengan baik.

Buat set-Method sendiri dan gunakan dalam init-Method Anda:

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

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

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

Dengan mendeklarasikan somePropertysebagai tipe: AnyObject!(sebuah opsi yang secara implisit tidak terbuka), Anda mengizinkan diri untuk menginisialisasi sepenuhnya tanpa somePropertydisetel. Saat Anda menelepon, setSomeProperty(someProperty)Anda menelepon yang setara dengan self.setSomeProperty(someProperty). Biasanya Anda tidak akan dapat melakukan ini karena diri belum sepenuhnya diinisialisasi. Karena somePropertytidak memerlukan inisialisasi dan Anda memanggil metode yang bergantung pada diri sendiri, Swift meninggalkan konteks inisialisasi dan didSet akan berjalan.

Jika Anda menggunakan deferdalam sebuah initializer , untuk memperbarui setiap sifat opsional atau memperbarui lanjut sifat non-opsional yang Anda sudah diinisialisasi dan setelah Anda disebut setiap super.init()metode, maka Anda willSet, didSet, dll akan dipanggil. Saya menemukan ini lebih nyaman daripada menerapkan metode terpisah yang Anda harus melacak panggilan di tempat yang tepat.

Sebagai contoh:

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

Akan menghasilkan:

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

Sebagai variasi jawaban Oliver, Anda bisa membungkus garis dengan penutupan. Misalnya:

class Classy {

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

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

}

Sunting: Jawaban Brian Westphal lebih baik imho. Hal yang baik tentang miliknya adalah bahwa itu mengisyaratkan maksudnya.

Saya memiliki masalah yang sama dan ini bekerja untuk saya

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

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

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

Ini berfungsi jika Anda melakukan ini dalam subkelas

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

Dalam acontoh, didSettidak dipicu. Tetapi dalam bcontoh, didSetdipicu, karena itu di dalam subkelas. Itu harus melakukan sesuatu dengan apa yang initialization contextsebenarnya berarti, dalam hal ini superclassmemang peduli tentang itu

Meskipun ini bukan solusi, cara alternatif untuk melakukannya adalah menggunakan konstruktor kelas:

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

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

Dalam kasus tertentu di mana Anda ingin meminta willSetatau didSetdi dalam inituntuk properti yang tersedia di superclass Anda, Anda dapat langsung menetapkan properti super Anda secara langsung:

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

Perhatikan bahwa solusi Charlesism dengan penutupan akan selalu berhasil juga dalam kasus itu. Jadi solusi saya hanyalah sebuah alternatif.

Anda dapat menyelesaikannya dengan cara 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
    }
}