In accordance with Wikipedia:

In laptop programming, lazy initialization is the tactic of delaying the creation of an object, the calculation of a worth, or another costly course of till the primary time it’s wanted.

That little quote just about sums up the whole lot, nonetheless as a result of we’re working with the Swift programming language, we’ve a factor referred to as optionals. If you do not know what are these, please learn the linked articles first, and are available again afterwards. 🤐

The final word information of being lazy

When a property is just wanted sooner or later in time, you may prefix it with the lazy key phrase so it’s going to be “excluded” from the initialization course of and it is default worth shall be assigned on-demand. This may be helpful for varieties which might be costly to create, or wants extra time to be created. Here’s a fast story of a lazy princess. 👸💤

class SleepingBeauty {

    init() {
        print("zzz...sleeping...")
        sleep(2)
        print("sleeping magnificence is prepared!")
    }
}

class Citadel {

    var princess = SleepingBeauty()

    init() {
        print("fort is prepared!")
    }
}

print("a brand new fort...")
let fort = Citadel()

The output of this code snippet is one thing like under, however as you may see the princess is sleeping for a really very long time, she can also be “blocking” the fort. 🏰

a brand new fort...
zzz...sleeping...
sleeping magnificence is prepared!
fort is prepared!

Now, we will pace issues up by including the lazy keword, so our hero can have time to slay the dragon and our princess can sleep in her mattress till she’s wanted… 🐉 🗡 🤴

class SleepingBeauty {

    init() {
        print("zzz...sleeping...")
        sleep(2)
        print("sleeping magnificence is prepared!")
    }
}

class Citadel {

    lazy var princess = SleepingBeauty()

    init() {
        print("fort is prepared!")
    }
}

print("a brand new fort...")
let fort = Citadel()
fort.princess

A lot better! Now the fort is immediately prepared for the battle, so the prince can get up his beloved one and… they lived fortunately ever after. Finish of story. 👸 ❤️ 🤴

a brand new fort...
fort is prepared!
zzz...sleeping...
sleeping magnificence is prepared!

I hope you loved the fairy story, however let’s do some actual coding! 🤓

Avoiding optionals with lazyness

As you’ve got seen within the earlier instance lazy properties can be utilized to enhance the efficiency of your Swift code. Additionally you may eradicate optionals in your objects. This may be helpful in case you’re coping with UIView derived lessons. For instance in case you want a UILabel to your view hierarchy you normally should declare that property as non-compulsory or as an implicitly unwrapped non-compulsory saved property. Let’s remake this instance by utilizing lazy & eliminating the necessity of the evil non-compulsory requirement. 😈

class ViewController: UIViewController {

    lazy var label: UILabel = UILabel(body: .zero)

    override func loadView() {
        tremendous.loadView()

        self.view.addSubview(self.label)
    }

    override func viewDidLoad() {
        tremendous.viewDidLoad()

        self.label.textColor = .black
        self.label.font = UIFont.systemFont(ofSize: 16, weight: .daring)
    }
}

It is not so unhealthy, nonetheless I nonetheless favor to declare my views as implicitly unwrapped optionals. Possibly I am going to change my thoughts in a while, however outdated habits die exhausting… 💀

Utilizing a lazy closure

You should utilize a lazy closure to wrap a few of your code inside it. The primary benefit of being lazy – over saved properties – is that your block shall be executed ONLY if a learn operation occurs on that variable. You may as well populate the worth of a lazy property with an everyday saved proeprty. Let’s examine this in apply.

class ViewController: UIViewController {

    lazy var label: UILabel = {
        let label = UILabel(body: .zero)
        label.translatesAutoresizingMaskIntoConstraints = false
        label.textColor = .black
        label.font = UIFont.systemFont(ofSize: 16, weight: .daring)
        return label
    }()
}

This one is a pleasant apply if you would like to declutter your init methodology. You possibly can put all the thing customization logic inside a closure. The closure executes itself on learn (self-executing closure), so once you name self.label your block shall be executed and voilá: your view shall be prepared to make use of.

You possibly can’t use self in saved properties, however you might be allowed to take action with lazy blocks. Watch out: you must all the time use [unowned self], in case you do not wish to create reference cycles and reminiscence leaks. ♻️

Lazy initialization utilizing factories

I have already got a few articles about factories in Swift, so now i simply wish to present you find out how to use a manufacturing unit methodology & a static manufacturing unit mixed with a lazy property.

Manufacturing facility methodology

When you do not like self-executing closures, you may transfer out your code right into a manufacturing unit methodology and use that one together with your lazy variable. It is easy like this:

class ViewController: UIViewController {

    lazy var label: UILabel = self.createCustomLabel()

    non-public func createCustomLabel() -> UILabel {
        print("referred to as")
        let label = UILabel(body: .zero)
        label.translatesAutoresizingMaskIntoConstraints = false
        label.textColor = .black
        label.font = UIFont.systemFont(ofSize: 16, weight: .daring)
        return label
    }
}

Now the manufacturing unit methodology works like a personal initializer to your lazy property. Let’s convey this one step additional, so we will enhance reusability somewhat bit…

Static manufacturing unit

Outsourcing your lazy initializer code right into a static manufacturing unit could be a good apply if you would like to reuse that code in a number of components of your software. For instance this can be a good match for initializing customized views. Additionally making a customized view shouldn’t be actually a view controller process, so the duties on this instance are extra separated.

class ViewController: UIViewController {

    lazy var label: UILabel = UILabel.createCustomLabel()
}

extension UILabel {

    static func createCustomLabel() -> UILabel {
        let label = UILabel(body: .zero)
        label.translatesAutoresizingMaskIntoConstraints = false
        label.textColor = .black
        label.font = UIFont.systemFont(ofSize: 16, weight: .daring)
        return label
    }
}

As a free of charge you may take pleasure in some great benefits of static manufacturing unit properties / strategies, like caching or returning particular subtypes. Fairly neat! 👍

Conclusion

Lazy variables are a very handy strategy to optimize your code, nonetheless they’ll solely used on structs and lessons. You possibly can’t use them as computed properties, this implies they will not return the closure block each time you are attempting to entry them.

One other necessary factor is that lazy properties are NOT thread secure, so it’s important to watch out with them. Plus you do not all the time wish to eradicate implicitly unwrapped non-compulsory values, typically it is simply approach higher to easily crash! 🐛

Do not be lazy!

…however be happy to make use of lazy properties each time you may! 😉