Swift Lazy Stored Property Versus Regular Stored Property When Using Closure

Swift lazy stored property versus regular stored property when using closure

import Foundation
struct S {
    var date1: NSDate = {
        return NSDate()
    }()
    lazy var date2: NSDate = {
        return NSDate()
    }()
}

var s = S()
sleep(5)
print( s.date2, s.date1)
/* prints

2015-11-24 19:14:27 +0000 2015-11-24 19:14:22 +0000

*/

both are stored properties, check the real time at which they are evaluated. the lazy property is evaluated 'on demand' when first time the value is needed

Swift must use lazy for stored property when use self in closure?

When you are declaring label with lazy initial value is not calculated until the first time it is used.
so the probably the Instantiates views was completed.

But the concept of using let in Swift, variables which are let have to be initialized before you can use self.

Using lazy var means that the compiler can verify that the value assigned to label won't be accessed before self is a valid object, because it won't be possible to call label until all other members of the class have been initialized.

Swift function vs lazy var vs computed property - difference?

• lazy vars are actually stored properties, so you can't put it in extensions or anywhere stored properties are not allowed.
• The getter for computed properties is run every time you refer to that property. This can be significant especially if the getter is time-consuming or has side-effects to other parts of the code.
• The getter for lazy vars are only run when the property is first referred to and never again.
• lazy vars are variables. You can mutate them.
• Computed properties can optionally have a setter, so sometimes they are read-only.
• Using a function like that is very similar to a read only computed property. You just have to add () when getting its value.

What is the advantage of a lazy var in Swift

Lazy Stored Property vs Stored Property

There are a few advantages in having a lazy property instead of a stored property.

1. The closure associated to the lazy property is executed only if you read that property. So if for some reason that property is not used (maybe because of some decision of the user) you avoid unnecessary allocation and computation.
2. You can populate a lazy property with the value of a stored property.
3. You can use self inside the closure of a lazy property

Difference between computed property and property set with closure

In short, the first is a stored property that is initialized via a closure, with that closure being called only one time, when it is initialized. The second is a computed property whose get block is called every time you reference that property.

---

The stored property’s initialization closure is called once and only once, but you can later change the value of the stored property (unless you replace var with let). This is useful when you want to encapsulate the code to initialize a stored property in a single, concise block of code.

The computed property’s block, however, is called each time you reference the variable. It’s useful when you want the code to be called every time you reference the computed property. Generally you do this when the computed property needs to be recalculated every time you reference the stored property (e.g. recalculated from other, possibly private, stored properties).

In this case, you undoubtedly want the stored property (the first example), not the computed property (the second example). You presumably don't want a new push behavior object each time you reference the variable.

---

By the way, in your first example, you internally reference to it being instantiated lazily. If you want that behavior, you must use the lazy keyword:

lazy var pushBehavior: UIPushBehavior = {
    let behavior = UIPushBehavior()
    behavior.setAngle(50, magnitude: 50)
    return behavior
}()

If, however, the property is static, it is automatically instantiated lazily.

Difference between Lazy var and var as-a-closure in Swift

The difference is when the init code for the variable is run. For lazy vars, the init code is run on first access of that variable. For non-lazy vars, it's run when the struct/class is initialized.

struct N {
    lazy var a: Int = { print("Setting A"); return 5}();
    var b: Int = { print("Setting B"); return 5 }()
}

var n = N()
print(n.a)
print(n.b)

Output:

Setting B
Setting A
5
5

Note how non-lazy b is initialized first. a is only initialized when it's accessed. In either case, the initializer for each property is only run once.

Swift: why lazy, computed property, and property observer can not be let

Lazy properties : You must always declare a lazy property as a variable (with the var keyword), because its initial value might not be retrieved until after instance initialization completes. Constant properties must always have a value before initialization completes, and therefore cannot be declared as lazy.

computed property : whereas computed properties calculate (rather than store) a value. Instead, they provide a getter and an optional setter to retrieve and set other properties and values indirectly.

property observer : property observers is to monitor changes in a property’s value, if you define it let then how you can monitor changes because let is one type of constant which you can not change after init.

lazy properties vs function in Swift 3

A full name of lazy properties in Swift is lazy stored property, which means that the value of the property is stored as soon as it is computed the first time it is needed. No additional computations is performed when you reference the same property again.

The result of a function, on the other hand, is computed each time that you call the function.

Here is your modified code that demonstrates this point:

struct Person {
    var personName:String?
    init(name:String) {
        personName=name
    }

    lazy var greetLazy:String = {
        print("Computing property...")
        return "Hello \(self.personName!)"
    }()

    func greetFunc()->String
    {
        print("Computing function...")
        return "Hello \(self.personName!)"
    }
}

var person:Person=Person(name:"")
print(person.greetLazy)
print(person.greetFunc())
print(person.greetLazy)
print(person.greetFunc())

Above prints "Computing property..." only once, while "Computing func..." is printed twice.

---

Related Topics