Initializing by lazy and lateinit variables in Kotlin

https://thoughtsoncloud.com/initializing-lazy-and-lateinit-variables-in-kotlin/

Initializing by lazy and lateinit variables in Kotlin

In Kotlin, the lateinit and by lazy keywords ensure convenient ways to handle parameter beginning. They ensure flexibility and efficiency when working with variables that are not always available or are expensive to calculate. This article explores the concepts of lateinit and by lazy in Kotlin, their differences, and when to use each.

Initializing by lazy and lateinit variables in Kotlin

by

Viktoriia Domukhovska

Updated: July 12, 2023

In Kotlin, the lateinit and by lazy keywords ensure convenient ways to handle parameter beginning. They ensure flexibility and efficiency when working with variables that are not always available or are expensive to calculate. This article explores the concepts of lateinit and by lazy in Kotlin, their differences, and when to use each.

lateinit keyword

The lateinit keyword allows us to declare non-nullable variables without immediately initializing them. These variables must be of type var and their beginning is deferred until later in code execution. However, using a lateinit parameter before beginning results in a NullPointerException.

by lazy keyword

The by lazy function is a delegated property that calculates its value only the 1st time it is approached. It takes a lambda expression that is evaluated and cached, and then approaching the parameter returns the cached value. By default, by lazy properties are immutable (val) and thread-safe.

Features of lateinit work

Expanding on my last point, lateinit can be used well with non-primitive data types. It can only be applied to non-primitive types, such as classes and objects. The functionality is not compatible with primitive types such as long or int. This limitation arises because whenever a lateinit property is approached, Kotlin internally assigns it a null value to signify that the property has not yet been initialized.

When working with lateinit variables in Kotlin, it is crucial to ensure that they are properly begun before approaching them. Failing to initialize a lateinit parameter before usage will result in a NullPointerException. Here are some approaches for handling uninitialized lateinit variables:

Initializing in the same scope: Initialize the lateinit parameter within the same function or scope before any usage of the variable. This ensures that the parameter is begun before it is approached.

lateinit
var testVar: String

fun setupVar() {
    testVar = "Test value"
    //Set value for variable 'testVar'
}

Using a null check: Perform a null check before approaching the lateinit parameter to ensure it has begun. This helps avoid the risk of NullPointerException. Using the isInitialized property: Kotlin ensures the isInitialized property to check if a lateinit parameter has been begun. You can use this property to conditionally handle the beginning status of the variable.

fun checkIsVarInitialized() {
    if (::testVar.isInitialized) {
        // Use testVar safely
        println(testVar)
    } else {
        // Handle the case when testVar is not initialized
    }
}

Features of by lazy work

Through the delegate method, lazy beginning is accomplished using the by lazy keyword. The lambda expression you want to use to run the code to initialize the property is what the lazy delegate accepts.

When a parameter needs to be declared, beginning is sometimes postponed. Initialization delays can have a wide range of causes. For instance, beginning necessitates pre-computation, which is preferable to avoid if the outcome won’t ever be used. In these circumstances, the parameter is typically declared as var, which initially has the value null and remains that way forever.

var phoneModel: String ? = null
    ...
    phoneModel = getPhoneModel() //assigning a value

fun getPhoneModel(): String {
    return“ some phone model”
}

This is problematic if you wish to prevent null values and know the parameter will have a specific value. While it may be of type String in our case, the parameter is of type String?, which permits null. Alternatively, you might use a predetermined value, like in:

var phoneModel: String = "NOTHING"
// or the empty string
var phoneModel: String = ""
...
phoneModel = getPhoneModel()

However, even though the variable’s value won’t change after beginning, you still need to utilize var. Kotlin advises using by lazy in certain circumstances:

val phoneModel: String by lazy {
    getPhoneModel()
}

In this example, the getPhoneModel() function will be called only once, when phoneModel is retrieved for the 1st time. You can also use a function reference instead of a lambda expression:

val phoneModel: String by lazy(::getPhoneModel)

Differences between lateinit and by lazy

The main differences between lateinit and by lazy in Kotlin are as follows:

1. Initialization time:
   • lateinit: lateinit variables are initialized before their 1st usage, typically within the same function or scope. The beginning can occur at a later point in the code execution, but approaching a lateinit parameter before beginning will result in a NullPointerException.
   • by lazy: by lazy properties are initialized when they are 1st approached. The beginning is deferred until the property is approached for the 1st time, which may happen at a different point in the program execution.
2. Mutability:
   • lateinit: lateinit variables are mutable (var), meaning their value can be reassigned after beginning. They can be used when the value needs to be updated or changed after beginning.
   • by lazy: by lazy properties are immutable (val), and their value cannot be changed once initialized. They are useful for scenarios where you don’t want the value to change after it’s 1st calculated.
3. Nullability:
   • lateinit: lateinit variables must be of a non-nullable type and cannot be assigned a null value. If a lateinit parameter is approached before being initialized, a NullPointerException will be thrown.
   • by lazy: by lazy properties can be assigned null values if their type allows it. However, once initialized, the value is fixed and cannot be null.
4. Usage Scenarios:
   • lateinit: lateinit is useful when you have a non-nullable property that cannot be initialized immediately but will be assigned a value before usage. It is commonly used in dependency injection scenarios or when properties are initialized from external sources.
   • by lazy: by lazy is beneficial when you want to defer the computation or beginning of a property until it is 1st approached. It is suitable for by lazy beginning, memoization, or situations where resource allocation is expensive and should be delayed until necessary.

It is essential to consider these differences when choosing between lateinit and by lazy based on the specific requirements and constraints of your Kotlin code.

Conclusion

In Kotlin, the lateinit and by lazy keywords offer powerful tools for parameter beginning. While lateinit is suitable for scenarios where the value will be assigned before usage, by lazy ensures deferred computation and efficient resource allocation. Understanding the differences between these two approaches allows developers to make informed decisions on which option to use based on the specific requirements of their code. By leveraging lateinit and by lazy, developers can improve performance, handle complex beginning scenarios, and optimize resource allocation.

To further enhance your understanding of lateinit and by lazy in Kotlin, I recommend watching the following video: lateinit vs by lazy in Kotlin.

Additionally, here is a code example showcasing the usage of lateinit and by lazy:

class ExampleClass {
    lateinit
    var lateInitVar: String

    val a = 37
    val b = 5

    val lazyVal: Int by lazy {
        // Perform expensive computation or beginning here
        a + b
    }

    fun setupVar(newValue: String) {
        lateInitVar = newValue
    }
}

//now we turn to these variables
fun main() {
    val testClass = TestClass()

    // approaching lateInitVar with initialization    
    testClass.setupVar("New value")
    println(testClass.lateInitVar) // Prints "New value"

    println(testClass.lazyVal) // Performs computation and prints 42
    println(testClass.lazyVal) // Returns cached value of 42
}

In this example, the lateInitVariable is declared using lateinit and is initialized by calling the setupVar()’ function. Attempting to approach lateInitVar before beginning would result in a NullPointerException.

On the other hand, the by lazyVal is a by lazy property that performs an expensive computation when approached for the 1st time. Subsequent approaches to by lazyVal return the cached value without recomputation.

In conclusion, understanding the differences between lateinit and by lazy in Kotlin enables developers to handle parameter beginning efficiently and effectively. By leveraging these keywords appropriately, developers can improve the performance and maintainability of their Kotlin codebase.