---
title: "Kotlin let Keyword Tutorial"
url: https://weworkworldwide.com/tutorials/kotlin-let-keyword-tutorial/
description: "Kotlin let Keyword Tutorial: In this section we will learn what the let keyword is and how to use it in Kotlin."
date: 2026-11-02T13:00:27+00:00
source: https://weworkworldwide.com/llms.txt
---

# Kotlin let Keyword Tutorial

In this section we will learn what the let keyword is and how to use it in Kotlin.

Note: we’re assuming you’re familiar with *the safe call operator in Kotlin*.

## What is let keyword in Kotlin?

The let statement is a way of running a block of code if the value of a variable is not null.

For example, let’s say you have a variable named emp which is of nullable type. Now you want to call this variable and run a task on it with the condition of only if the value of this variable is not null!

In such case we can create a block using the let keyword.

Alright, let’s see the syntax of this statement and then we’ll continue our discussion from there.

## Kotlin let keyword declaration syntax:

``` line-numbers
variable?.let{
//Instructions to run if the value of the variable is not null.
}
```

Here the `variable` is the one that is of type null and might not have an actual value! So we run the safe call operator to see if there’s a value behind the variable or not.

Now if and only if there’s an object for this variable, then the block of instructions that is defined in the body of the let keyword, will be executed.

Note that we used the dot operator and the let keyword with its block `{}` after the name of the nullable variable.

## Kotlin let and it keywords

Within the body of the `let` block we can use a keyword named `it` which refers to the object that the related variable (the one that the let block is created for) is referring to.

So using this `it` keyword we can invoke any member of that object.

## Example: using the let keyword in Kotlin

``` line-numbers
class Address{
var city:String = "LA"
var state:String = "CA"
}
class Employee{
var address:Address? = null
var firstName:String = "John"
var lastName:String = "Doe"
}
fun main(){
var address = Address()
var emp:Employee? = Employee()
emp?.address = address
emp?.let{
println("The emp variable has an object")
println(it.address?.city)
println(it.address?.state)
}
}
Output:
The emp variable has an object
LA
CA
```

## How does let keyword work in Kotlin?

Here the `emp` variable is called using the safe call operator and also we’ve defined a block for it to be executed if this variable does not have a null value.

Now because the emp variable has an actual object, then the block runs and we used the `it` keyword to access the object and invoke its members.

## Example: using let with array items

``` line-numbers
fun main(){
var names = arrayOf("Jack","Omid",null,"John","Ellen")
for (element in names){
element?.let{
println("The element of the array is: $element")
}
}
}
Output:
The element of the array is: Jack
The element of the array is: Omid
The element of the array is: John
The element of the array is: Ellen
```

Here we’ve checked every element of the array using the safe call operator and then if the value of that element wasn’t null, then the instructions defined in the let block will be run for that element.

Note: the let statement we’ve been mentioning in this section comes from something called lambda expression. We’ve devoted an entire article related to *the Kotlin lambda expressions.* You’ll learn about it in later sections.