← Back to Kotlin Course | Chapter 5: Null Safety | Lesson 3 of 6

Elvis Operator

The Elvis operator lets you say 'use this value, but if it's empty, use this backup value instead', all in one short line.

In this page:

  1. Providing a Default Value
  2. Combining with Safe Calls
  3. Throwing on Null with Elvis
  4. Lazy Evaluation of the Right Side
Syntax
kotlin 
val result = nullable ?: defaultValue
val result = obj?.property ?: defaultValue
val result = nullable ?: throw SomeException("message")

Providing a Default Value

The Elvis operator ?: returns its left operand if that is not null, or falls back to the right operand otherwise, giving a concise way to supply a default.

Example: Providing a Default Value

markup 
// Entry point: execution of the program starts here
fun main() {
    // Declare a read-only variable `nickname` (a `String?`), set to `null`
    val nickname: String? = null
    // Declare a read-only variable `displayName`, set to `nickname ?: "Anonymous"`
    val displayName = nickname ?: "Anonymous"
    // Print "Display name: $displayName" to the console, with a trailing newline
    println("Display name: $displayName")
}

Combining with Safe Calls

?: pairs naturally with ?., letting you write value?.property ?: default to safely reach into a nullable chain and fall back cleanly if anything along the way is null.

Example: Combining with Safe Calls

markup 
// Define a data class `User`
data class User(val name: String?)

// Entry point: execution of the program starts here
fun main() {
    // Declare a read-only variable `user` (a `User?`), set to `User(null)`
    val user: User? = User(null)
    // Declare a read-only variable `name`, set to `user?.name ?: "Unknown"`
    val name = user?.name ?: "Unknown"
    // Print "Name: $name" to the console, with a trailing newline
    println("Name: $name")
}

Throwing on Null with Elvis

Because the right side of ?: can be any expression, including throw, it is a common idiom to fail fast with a clear exception when a value that should never be null turns out to be.

Example: Throwing on Null with Elvis

markup 
// Define the function `requireName` taking `name` and returning a String
fun requireName(name: String?): String {
    // Return `name ?: throw IllegalArgumentException("Name must not be null")` from this function
    return name ?: throw IllegalArgumentException("Name must not be null")
}

// Entry point: execution of the program starts here
fun main() {
    // Print `requireName("Kotlin")` to the console, with a trailing newline
    println(requireName("Kotlin"))
}

Lazy Evaluation of the Right Side

The expression after ?: is only evaluated if the left side is null, so an expensive computation or a function call placed there does not run unnecessarily.

Note: Notice "Computing default..." never prints, since value was not null.

Example: Lazy Evaluation of the Right Side

markup 
// Define the function `computeExpensiveDefault` with no parameters and returning a String
fun computeExpensiveDefault(): String {
    // Print "Computing default..." to the console, with a trailing newline
    println("Computing default...")
    // Return `"computed"` from this function
    return "computed"
}

// Entry point: execution of the program starts here
fun main() {
    // Declare a read-only variable `value` (a `String?`), set to `"already set"`
    val value: String? = "already set"
    // Declare a read-only variable `result`, set to `value ?: computeExpensiveDefault()`
    val result = value ?: computeExpensiveDefault()
    // Print "Result: $result" to the console, with a trailing newline
    println("Result: $result")
}
Related Topics

Safe Call Operator · Spread Operator · Operator Overloading · Non-Null Assertion

{# common_mistakes/chapter_summary/browser_support: on Hindi pages the view already swaps in the hi_ translation fields (or blanks these out if untranslated), so this renders correctly for both languages without a lang_code check here. #}
Common Mistakes
  1. Forgetting the Elvis operator's right-hand side is only evaluated when the left side is null, and relying on it to run unconditionally.
  2. Using if/else verbosely for a simple default-value case where ?: would be far shorter and clearer.
  3. Chaining ?: with a throw and not realizing this is a common, idiomatic way to fail fast on unexpected nulls.
Chapter Summary
  • a ?: b evaluates to a if a is not null, otherwise it evaluates to b.
  • The right-hand side of ?: is only evaluated when needed (it is lazy), so it can safely contain a function call or a throw.
  • The Elvis operator is often combined with a safe call, like user?.name ?: "Unknown".
  • ?: can be used to provide a default value or to fail fast with a throw/return when a value is unexpectedly null.
🔒

Chapter Quiz — Complete all 6 topics to unlock

0/6 topics done

Complete these topics first:

← Previous Lesson Safe Call Operator Next Lesson → Non-Null Assertion

Login to run this code

C/C++/Java/PHP execution requires a free account. Your code is saved — you'll land right back in the editor after logging in.