What are lazy vars in Swift? – Donny Wals

Generally whenever you’re programming you could have some properties which are fairly costly to compute so that you need to just remember to don’t carry out any work that you just don’t completely should carry out.

For instance, you might need the next two standards on your property:

• The property needs to be computed as soon as
• The property needs to be computed solely once I want it

If these two standards sound like what you’re on the lookout for, then lazy vars are for you.

A lazy variable is outlined as follows:

class ExamResultsAnalyser {
  let allResults: [ExamResult]

  lazy var averageGrade: Float = {
    return allResults.cut back(0.0, { whole, lead to
      return whole + consequence.grade
    }) / Float(allResults.depend)
  }()

  init(allResults: [ExamResult]) {
    self.allResults = allResults
  }
}

Discover the syntax that is used to create our lazy var. The variable is outlined as a var and never as a let as a result of accessing the property mutates our object. Additionally discover that we’re utilizing a closure to initialize this property. This isn’t obligatory however it’s by far the commonest means I’ve initialized my lazy var properties to date. If you wish to study extra about closures as an initialization mechanism, check out this submit the place I discover the subject in depth.

On this case, we’re attempting to calculate a median grade based mostly on some examination outcomes. If we solely want to do that for a handful of scholars this is able to be lightning quick but when we have to do that for a pair thousand college students we’d need to postpone the calculation to the final doable second. And since an examination result’s immutable, we don’t actually need to recalculate the common each time we entry the averageGrade property.

That is truly a key distinction between computed properties and a lazy var. Each are used to compute one thing upon entry, however a computed property performs its computation each time the property is accessed. A lazy var alternatively solely computes its worth as soon as; upon first entry.

Word that accessing a lazy var counts as a mutating motion on the enclosing object. So when you add a lazy var to a struct, the next code wouldn’t compile:

struct ExampleStruct {
  lazy var randomNumber = Int.random(in: 0..<100)
}

let myStruct = ExampleStruct()
myStruct.randomNumber

The compiler will present the next error:

Can not use mutating getter on immutable worth: ‘myStruct’ is a ‘let’ fixed

And it’ll provide the next repair:

Change ‘let’ to ‘var’ to make it mutable

As a result of accessing the lazy var is a mutating operation, we should outline our myStruct fixed as a variable if we wish to have the ability to entry the randomNumber lazy var.

In Abstract

All in all lazy var is an extremely useful gizmo when it’s good to postpone initialization for a property to the final doable millisecond, and particularly when it’s not assured that you just’ll must entry the property in any respect.

Word {that a} lazy var doesn’t magically make the (costly) computation that you just’re doing quicker. It merely permits you to not do any work till the work truly must be accomplished. When you’re fairly certain that your lazy var will likely be accessed in a overwhelming majority of instances it’s value contemplating not making the property lazy in any respect; the work will should be accomplished in some unspecified time in the future both means, and having much less complexity is at all times an excellent factor in my guide.