Có thể cho phép did set được gọi trong quá trình khởi tạo trong Swift không?

Câu hỏi

Tài liệu của Apple chỉ định rằng:

Các quan sát viên will set và did set không được gọi khi một thuộc tính được khởi tạo lần đầu tiên. Chúng chỉ được gọi khi giá trị của thuộc tính được đặt bên ngoài bối cảnh khởi tạo.

Có thể buộc những thứ này được gọi trong quá trình khởi tạo không?

Tại sao?

Hãy nói tôi có lớp học này

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

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

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

Tôi đã tạo phương thức doStuff, để làm cho các cuộc gọi xử lý ngắn gọn hơn, nhưng tôi chỉ muốn xử lý thuộc tính trong didSethàm. Có cách nào để buộc điều này để gọi trong quá trình khởi tạo không?

Cập nhật

Tôi quyết định chỉ gỡ bỏ intializer cho lớp của tôi và buộc bạn đặt thuộc tính sau khi khởi tạo. Điều này cho phép tôi biết didSetsẽ luôn luôn được gọi. Tôi đã không quyết định nếu điều này là tốt hơn về tổng thể, nhưng nó phù hợp với hoàn cảnh của tôi.

Tạo một Phương thức tập hợp riêng và sử dụng nó trong Phương thức init của bạn:

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

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

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

Bằng cách khai báo somePropertydưới dạng: AnyObject!(một tùy chọn ngầm định chưa được mở), bạn cho phép tự khởi tạo hoàn toàn mà không somePropertyđược đặt. Khi bạn gọi setSomeProperty(someProperty)bạn đang gọi tương đương self.setSomeProperty(someProperty). Thông thường bạn sẽ không thể làm điều này vì bản thân chưa được khởi tạo hoàn toàn. Vì somePropertykhông yêu cầu khởi tạo và bạn đang gọi một phương thức phụ thuộc vào bản thân, Swift rời khỏi bối cảnh khởi tạo và did set sẽ chạy.

Nếu bạn sử dụng deferbên trong một initializer , để cập nhật bất kỳ thuộc tính tùy chọn hoặc tiếp tục cập nhật các thuộc tính phi tùy chọn mà bạn đã khởi tạo và sau khi bạn gọi bất kỳ super.init()phương pháp, sau đó bạn willSet, didSetvv sẽ được gọi. Tôi thấy điều này thuận tiện hơn việc thực hiện các phương pháp riêng biệt mà bạn phải theo dõi cuộc gọi ở đúng nơi.

Ví dụ:

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

Sẽ mang lại:

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

Như một biến thể của câu trả lời của Oliver, bạn có thể gói các dòng trong một bao đóng. Ví dụ:

class Classy {

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

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

}

Chỉnh sửa: Câu trả lời của Brian Hampal đẹp hơn imho. Điều tốt đẹp về anh ấy là nó gợi ý về ý định.

Tôi đã có cùng một vấn đề và điều này làm việc cho tôi

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

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

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

Điều này hoạt động nếu bạn làm điều này trong một lớp con

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

Trong aví dụ, didSetkhông được kích hoạt. Nhưng trong bví dụ, didSetđược kích hoạt, bởi vì nó nằm trong lớp con. Nó phải làm một cái gì đó với những gì initialization contextthực sự có nghĩa là, trong trường hợp này superclassđã quan tâm đến điều đó

Mặc dù đây không phải là một giải pháp, một cách khác để thực hiện nó là sử dụng một hàm tạo của lớp:

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

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

Trong trường hợp cụ thể mà bạn muốn gọi willSethoặc didSetbên trong initcho một thuộc tính có sẵn trong siêu lớp của bạn, bạn chỉ cần trực tiếp gán siêu tài sản của mình:

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

Lưu ý rằng giải pháp Charlesism với việc đóng cửa sẽ luôn hoạt động trong trường hợp đó. Vì vậy, giải pháp của tôi chỉ là một thay thế.

Bạn có thể giải quyết nó theo cách 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
    }
}