Call methods from Swift initializer

Question

Let's say I have the following class in Swift (which has obvious problems)

class MyClass {
    let myProperty: String

    init() {
        super.init()
        self.setupMyProperty()
    }

    func setupMyProperty() {
        myProperty = "x"
    }
}

This is overly simplified but I'm basically trying to delegate the initialization of myProperty into the setupMyProperty() method. It's a pattern I use often to break down the different parts of the setup of a class.

But of course, I can't call self until the super initializer has run, and I can't run the super initializer until all the properties have been set, so I'm in a catch 22. On top of it since setupMyProperty() isn't considered an initializer, it won't be able to assign myProperty anyway.

Can anyone tell me how to implement this pattern in Swift?

Answer 1

declare it as an implicitly unwrapped optional

class MyClass : NSObject {
    var myProperty: String!

    init() {
        super.init()
        self.setupMyProperty()
    }

    func setupMyProperty() {
        self.myProperty = "x"
    }
}

page 499 of "The Swift Programming Language" manual

Answer 2

Does setupMyProperty need to access self? If not, you can achieve this with a class method:

class MyClass: NSObject {
    let myProperty: String

    init() {
        myProperty = MyClass.setupMyProperty()
        super.init()
    }

    class func setupMyProperty() -> String {
        return "foo"
    }
}

Answer 3

You can't use self until your instance's memory is fully initialized (at which point you can't set constant properties anymore), so the order in which your designated initializer has to do things is:

1. initialize all properties added by this class
2. call superclass initializer (if there is a superclass)
3. now you can use self, call methods, etc

I'm not sure if there's a good workaround for the case of a constant property. One alternative would be to declare the property as an implicitly unwrapped optional, so it's initially set to nil:

class MyClass {
    var myProperty: String!
    init() {
        super.init() // only if you actually have a superclass, and make sure this does not use `myProperty`
        self.setupMyProperty()
    }

    func setupMyProperty() {
        myProperty = "x"
    }
}

Be careful with this, it loses a bit of type safety, as myProperty can now be nil, and if it is when you try to access it, it will lead to a runtime error. So only do this if you're sure it'll be initialized by all your designated initializers, not be used by anything called before setupMyProperty() in the initializer chain (e.g. when a superclass initializer calls a method you override that accesses myProperty), and never set to nil explicitly.

Also, cf. the docs, especially the section on Class Inheritance and Initialization for the whole call-order stuff I explained above.

Answer 4

Try putting setupMyProperty() in a constant. Then it is there before you initialise and you can call it from init(). You can even access parameters as follows:

class MyClass {
    var myProperty: String
    let setupMyProperty : (String) -> (void) = { 
        param in
        self.myProperty = param
    }

    init(x: String) {
    // removed redundant line: super.init()
        self.setupMyProperty(x)
    }
}

Answer 5

class MyClass {

    let myProperty: String

    init() {
        super.init()
        self.myProperty = {
          // do your logic here 
          return "x" 
        }()
    }
}

Answer 6

Surprised to see the top voted answer.. It risks a lot of safety using an implicitly unwrapped optional.

If you're looking reset your properties, but keep one source of truth, use a Constants struct

class MyClass {
    var myProperty = Constants.myProperty
    
    init() {
        reset()
    }
    
    func reset() {
        myProperty = Constants.myProperty
    }
    
    struct Constants {
        static let myProperty = "hello"
    }
}

If you want to hide complicated set up logic away from init, use a static func

class MyClass {
    var myProperty: String
    
    init() {
        myProperty = MyClass.setUpProperty()
    }
    
    static func setUpProperty() -> String {
        // Complicated set up logic goes here..
        return "hello"
    }
}

If you're looking to have different initializers for an object, use a Constants struct combined with initialization logic

class MyClass {
    var myProperty = Constants.myProperty1
    
    init() {
        if externalState {
            init1()
        } else {
            init2()
        }
    }
    
    func init1() {
        myProperty = Constants.myProperty1
    }
    
    func init2() {
        myProperty = Constants.myProperty2
    }
    
    struct Constants {
        static let myProperty1 = "hello"
        static let myProperty2 = "there"
    }
}