> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Kotlin Nullable Variable
A nullable variable in Kotlin is a variable whose type explicitly permits the assignment of a `null` reference. Kotlin's type system strictly distinguishes between references that can hold `null` (nullable types, denoted as `T?`) and those that cannot (non-nullable types, denoted as `T`), enforcing null safety at compile-time to prevent runtime `NullPointerException`s.
To declare a nullable variable, append a question mark (`?`) to the base type declaration.
```kotlin theme={"dark"}
var nonNullableString: String = "Hello"
// nonNullableString = null // Compilation error
var nullableString: String? = "Hello"
nullableString = null // Valid assignment
```
Because a nullable variable `T?` acts as a union type of `T | null`, the Kotlin compiler prohibits direct access to the underlying `T` member properties or functions. However, direct access is permitted for extension functions or properties explicitly defined on the nullable type `T?` (such as `nullableString.isNullOrEmpty()` or `nullableString.toString()`). To access members of the underlying `T` type, you must explicitly resolve the nullability using one of Kotlin's built-in operators or control flow mechanisms.
## Safe Call Operator (`?.`)
The safe call operator evaluates the expression if the variable is not null. If the variable is null, the entire expression short-circuits and evaluates to `null`.
```kotlin theme={"dark"}
val length: Int? = nullableString?.length
```
## Elvis Operator (`?:`)
The Elvis operator unwraps a nullable variable by providing a default non-null fallback value. If the expression on the left is not null, it returns that value; otherwise, it returns the expression on the right.
```kotlin theme={"dark"}
val length: Int = nullableString?.length ?: 0
```
## Not-Null Assertion Operator (`!!`)
The not-null assertion operator forcefully casts a nullable type `T?` to a non-nullable type `T`, bypassing the compiler's null safety checks. If the variable holds a `null` value at runtime, this operator explicitly throws a `NullPointerException`.
```kotlin theme={"dark"}
val length: Int = nullableString!!.length
```
## Smart Casting
When a nullable variable is explicitly checked against `null` using standard conditional logic, the Kotlin compiler tracks this state and automatically "smart casts" the variable to its non-nullable counterpart within the scope of that check.
```kotlin theme={"dark"}
if (nullableString != null) {
// The compiler smart-casts String? to String
val length: Int = nullableString.length
}
```
**Limitation:** Smart casts are strictly limited to variables where the compiler can guarantee the reference has not been modified by another thread or scope between the null check and the usage. Consequently, smart casting **does not work** on mutable class-level properties (`var`) or local `var` declarations that are captured and modified within lambdas.
## Safe Unwrapping with `?.let`
The `let` scope function, combined with the safe call operator (`?.let`), is a fundamental and idiomatic mechanism for safely unwrapping a nullable variable. It executes the provided lambda block only if the variable is not null, exposing a non-nullable reference (defaulting to `it`) inside the block. This pattern serves as the primary workaround for the smart casting limitations on mutable properties.
```kotlin theme={"dark"}
var mutableNullableString: String? = "Kotlin"
// Bypasses smart cast limitations by capturing the non-null value in a local scope
mutableNullableString?.let { nonNullString ->
val length: Int = nonNullString.length
}
```
## Safe Cast Operator (`as?`)
When casting types, the safe cast operator attempts to cast a variable to a target type. If the variable is not of the target type, it returns `null` instead of throwing a `ClassCastException`, resulting in a nullable variable.
```kotlin theme={"dark"}
val anyValue: Any = "Kotlin"
val number: Int? = anyValue as? Int // Evaluates to null
```
Tired of Poor Kotlin Skills? Fix That With Deep Grasping!
Learn More
