เป็นไปได้ไหมที่จะอนุญาตให้เรียกใช้ 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ฟังก์ชัน มีวิธีบังคับให้สิ่งนี้เรียกในระหว่างการเริ่มต้นหรือไม่?

ปรับปรุง

ฉันตัดสินใจที่จะลบเครื่องมืออำนวยความสะดวกสำหรับชั้นเรียนของฉันและบังคับให้คุณตั้งค่าคุณสมบัติหลังจากเริ่มต้น สิ่งนี้ทำให้ฉันรู้ว่า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เป็นประเภท: AnyObject!(ตัวเลือกที่ยังไม่ได้เปิดใช้โดยปริยาย) คุณอนุญาตให้ตัวเองเริ่มต้นได้อย่างเต็มที่โดยไม่ต้อง somePropertyตั้งค่า เมื่อคุณเรียก คุณโทรเทียบเท่าsetSomeProperty(someProperty) self.setSomeProperty(someProperty)โดยปกติคุณจะไม่สามารถทำสิ่งนี้ได้เพราะตนเองยังไม่ได้เริ่มต้นอย่างเต็มที่ เนื่องจาก 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

ในรูปแบบของคำตอบของ Oliver คุณสามารถพันบรรทัดด้วยการปิด เช่น:

class Classy {

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

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

}

แก้ไข: คำตอบของ Brian Westphal คือ nicer 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
}

โปรดทราบว่าวิธีการแก้ปัญหาของ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
    }
}