What are lazy vars in Swift? – Donny Wals

Generally while you’re programming you might have some properties which are fairly costly to compute so that you wish to just be sure you don’t carry out any work that you just don’t completely should carry out.

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

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

If these two standards sound like what you’re searching 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 + outcome.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 method I’ve initialized my lazy var properties thus far. 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 wish to postpone the calculation to the final attainable second. And since an examination result’s immutable, we don’t actually wish 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 however solely computes its worth as soon as; upon first entry.

Be aware that accessing a lazy var counts as a mutating motion on the enclosing object. So if you happen to 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 great tool when you have to postpone initialization for a property to the final attainable millisecond, and particularly when it’s not assured that you just’ll have to entry the property in any respect.

Be aware {that a} lazy var doesn’t magically make the (costly) computation that you just’re doing sooner. It merely means that you can not do any work till the work truly must be executed. Should you’re fairly certain that your lazy var can be accessed in a overwhelming majority of circumstances it’s price contemplating not making the property lazy in any respect; the work will must be executed in some unspecified time in the future both method, and having much less complexity is all the time an excellent factor in my ebook.