Ios – Swift. Use of ‘self’ in method call before all stored properties are initialized

iosswift

I have a class

class ChartView: UIView
{
  class: DotView {
    let circleView1: UIView
    let circleView2: UIView

    init (view: UIView)
    {
      self.view = view
      self.circleView1 = self.buildCircle(some rect here)
      self.circleView2 = self.buildCircle(some rect here)

    func buildCircle(rect: CGRect) -> UIView
    {
       let dotView = UIView(frame: rect)
       dotView.backgroundColor = UIColor.whiteColor()
       dotView.layer.cornerRadius = dotView.bounds.width / 2
       self.view.addSubview(dotView)
       return dotView
    }
  }
}

But I got this error:
Use of 'self' in method call 'buildCircle' before all stored properties are initialized

So I just want to create objects in some method and then assign it to the stored properties. How can I fix my code?

Best Answer

You can't call methods on self before all non-optional instance variables are initialized. There are several ways to go around that.

Change properties to optionals or implicitly unwrapped optionals (not recommended)
Make the buildCircle() method static or just a function in the file and call the addSubview() for all the circles after all of the properties were initialized and you called super.init()
etc. You just have to avoid calls to self before the class was initialized.

Example: Making an asynchronous network request

If you are making an asynchronous network request you do want the closure to retain self for when the request finishes. That object may have otherwise been deallocated but you still want to be able to handle the request finishing.

When to use `unowned self` or `weak self`

The only time where you really want to use [unowned self] or [weak self] is when you would create a strong reference cycle. A strong reference cycle is when there is a loop of ownership where objects end up owning each other (maybe through a third party) and therefore they will never be deallocated because they are both ensuring that each other stick around.

In the specific case of a closure, you just need to realize that any variable that is referenced inside of it, gets "owned" by the closure. As long as the closure is around, those objects are guaranteed to be around. The only way to stop that ownership, is to do the [unowned self] or [weak self]. So if a class owns a closure, and that closure captures a strong reference to that class, then you have a strong reference cycle between the closure and the class. This also includes if the class owns something that owns the closure.

Specifically in the example from the video

In the example on the slide, TempNotifier owns the closure through the onChange member variable. If they did not declare self as unowned, the closure would also own self creating a strong reference cycle.

Difference between `unowned` and `weak`

The difference between unowned and weak is that weak is declared as an Optional while unowned is not. By declaring it weak you get to handle the case that it might be nil inside the closure at some point. If you try to access an unowned variable that happens to be nil, it will crash the whole program. So only use unowned when you are positive that variable will always be around while the closure is around

Swift – ‘Use of self in method call before super.init initializes self’, can’t init properties through a method call

Form documentation:

Swift’s compiler performs four helpful safety-checks to make sure that two-phase initialization is completed without error:

Safety check 1 A designated initializer must ensure that all of the properties introduced by its class are initialized before it delegates up to a superclass initializer.

You need to set value for instance variable before you call super.init() And after this action you will access to call instance methods. In your case you can do this:

override init (frame : CGRect) {
    self.collectionView = UICollectionView()
    super.init(frame : frame)
    // Now you can call method
    self.someMethod()
}

ADD for question's EDIT:

You can't call method before super.init() call because of safety reasons. If you will do it then your method can use some properties which have not yet been initialized in the parent class

Best Answer

Related Solutions

Swift – Shall we always use [unowned self] inside closure in Swift

Example: Making an asynchronous network request

When to use unowned self or weak self

Specifically in the example from the video

Difference between unowned and weak

Swift – ‘Use of self in method call before super.init initializes self’, can’t init properties through a method call

Related Topic

When to use `unowned self` or `weak self`

Difference between `unowned` and `weak`