Kotlin Elvis Operator

You are currently viewing Kotlin Elvis Operator

Kotlin Elvis Operator

In the realm of programming, handling null values is a task that developers encounter regularly. The Kotlin programming language, designed to be concise, expressive, and interoperable with Java, introduces a powerful tool to streamline null value handling – the Elvis Operator.

So, what exactly is this mysterious operator? Imagine a world where you never have to write endless if statements to check for nulls. A world where code is concise, and readable; that’s the power of the Elvis Operator (written as ?:).

What is the Elvis Operator?

Imagine you’re working with a variable that might be null (meaning it doesn’t hold any value). Usually, accessing a property or calling a method on a null variable leads to crashes and chaos. Not cool! That’s where the Elvis operator comes in. It serves as a shortcut for null checks and provides a default value if the variable is indeed null.

Think of the Elvis operator as a shortcut for handling null values. If the expression on the left of the ?: symbol is not null, it returns that value. But if it’s null, the operator returns the expression on the right.

The Basics: Using the Elvis Operator

You have a variable called name, and it could be either a real name or null. Instead of using the classic if-else statement, the Elvis operator lets you keep it snappy. Traditionally, you’d resort to a if statement:

import java.util.Random

fun getName(): String? =
    if(Random().nextInt(2) == 0) "Edward" else null

fun main() {

    val name: String? = getName()
    
    val displayName: String = if(name != null) {
        name
    } else {
        "Stranger"
    }

    println("Hello, $displayName!")

}

That’s fine, but wouldn’t it be smoother to express this in a single line? Enter the Elvis Operator, written as ?:.

import java.util.Random

fun getName(): String? =
    if(Random().nextInt(2) == 0) "Edward" else null

fun main() {

    val name: String? = getName()
    val displayName: String = name ?: "Stranger"

    println("Hello, $displayName!")

}

Here, the Elvis operator checks if name is not null. If it is, it returns the value of name. Otherwise, it returns the default value “Stranger”. This concise syntax saves you from writing lengthy if-else statements, making your code more readable and less error-prone.

Elvis Operator with Expressions

The Elvis Operator is not limited to simple assignments; it can also be used in expressions. Let’s consider a scenario where we want to perform an operation on a nullable value and provide a default result if the value is null.

import java.util.Random

fun fetchNullableNumber(): Int? {
    val value: Int = Random().nextInt(1, 11)
    return if(value < 6) value else null
}

fun main() {

    val nullableNumber: Int? = fetchNullableNumber()

    // Using Elvis Operator in an expression
    val result = nullableNumber?.times(2) ?: 0

    println(result)

}

In this example, if nullableNumber is not null, the Elvis Operator multiplies it by 2. If nullableNumber is null, the default value of 0 is used. This concise syntax enhances readability and maintains the flow of the code.

Elvis Operator in Safe Calls

The Elvis Operator is often used in conjunction with the safe call operator (?.) to perform null-safe operations. Consider a scenario where we have a nullable property within an object, and we want to access it safely with a default value in case of null.

import java.util.Random

data class Person(val name: String?)

// Simulating data retrieval
fun fetchPerson(): Person? =
    when (Random().nextInt(3)) {
        0 -> Person(name = "Edward")
        1 -> Person(name = null)
        else -> null
    }

fun main() {

    val person: Person? = fetchPerson()

    // Using safe call and Elvis Operator
    val nameLength = person?.name?.length ?: 0

    println("Name Length: $nameLength")

}

In this example, the Elvis Operator comes into play when accessing the name property of the Person object. If any intermediate property along the chain is null (either the person object or the name property of the person object), the entire expression evaluates to the default value of 0.

Elvis Operator in Function Calls

The Elvis Operator can be applied to function calls, making it handy when dealing with nullable return values from functions.

import java.util.Random

fun fetchNullableString(): String? =
    if(Random().nextInt(2) == 0)
        "Kotlin Programming Language"
    else
        null
        
fun calculateStringLength(str: String?): Int? {
    // Performing a computation on the nullable string
    return str?.length
}

fun main() {

    val nullableString = fetchNullableString();
    val length = calculateStringLength(nullableString) ?: 0

    println("String Length: $length")

}

In this example, the calculateStringLength function takes a nullable string as a parameter and returns the length if the string is not null; or null if the string is null. The Elvis Operator ensures that if the function returns null, the default length of 0 is used.

Conclusion

The Kotlin Elvis Operator is more than just a fancy name. It’s a powerful tool that promotes null-safety, readability, and concise code. Embrace its potential, and you’ll write Kotlin code that’s robust, elegant, and free from null-related headaches. Remember, with Elvis by your side, nulls become a breeze, not a burden.

Leave a Reply