Let function behavior and use cases in Kotlin - Mini Project: Build & Apply

Let function behavior and use cases

📖 Scenario: Imagine you have a list of names and you want to print a greeting only for the names that are not null. Using Kotlin's let function helps you do this safely and cleanly.

🎯 Goal: You will create a list with some nullable names, then use the let function to print greetings only for the non-null names.

📋 What You'll Learn

Create a list called names with nullable String values including null

Create a variable called greetingPrefix with the value "Hello"

Use a for loop to iterate over names and apply the let function to print greetings only for non-null names

Print the greeting in the format: Hello, [name]!

💡 Why This Matters

🌍 Real World

Handling nullable data safely is common in apps that get input from users or external sources. Using let helps avoid crashes and keeps code clean.

💼 Career

Understanding Kotlin's let function is important for Android developers and anyone working with Kotlin to write safe and readable code.

1

Create a list with nullable names

Create a list called names with these exact values: "Alice", null, "Bob", null, "Charlie"

Kotlin

# Create a list called names with nullable String values
# Your code here

Hint

Use listOf to create the list and include null values where specified.

2

Create a greeting prefix variable

Create a variable called greetingPrefix and set it to the string "Hello"

Kotlin

val names: List = listOf("Alice", null, "Bob", null, "Charlie")
# Create a variable greetingPrefix with value "Hello"
# Your code here

Hint

Use val greetingPrefix = "Hello" to create the variable.

3

Use let function to greet non-null names

Use a for loop with variable name to iterate over names. Inside the loop, use the let function on name to print the greeting in the format Hello, [name]!

Kotlin

val names: List = listOf("Alice", null, "Bob", null, "Charlie")
val greetingPrefix = "Hello"

# Use a for loop and let function to print greetings for non-null names
# Your code here

Hint

Use name?.let { ... } to run code only when name is not null.

4

Print the greetings

Run the program to print greetings for all non-null names in the list. The output should be exactly:
Hello, Alice!
Hello, Bob!
Hello, Charlie!

Kotlin

val names: List = listOf("Alice", null, "Bob", null, "Charlie")
val greetingPrefix = "Hello"

for (name in names) {
    name?.let {
        println("$greetingPrefix, $it!")
    }
}

# Run the program to see the output

Hint

Make sure your program prints exactly the greetings for non-null names, each on its own line.

Practice

1. What does the Kotlin let function primarily do when called on an object?

easy

A. Creates a new object identical to the original

B. Executes a block of code with the object as its argument and returns the block's result

C. Deletes the object after running the block

D. Converts the object to a string representation

Solution

1. Step 1: Understand the purpose of let

   The let function takes the object it is called on and passes it as an argument to a block of code.

2. Step 2: Identify the return value of let

   The result of the block inside let is returned as the final value of the let call.

3. Final Answer:

   Executes a block of code with the object as its argument and returns the block's result -> Option B

4. Quick Check:

   let runs block and returns result [OK]

Hint: Remember: let runs code and returns block result [OK]

Common Mistakes:

• Thinking let creates a new object
• Assuming let deletes the object
• Confusing let with toString conversion

2. Which of the following is the correct syntax to use let on a nullable variable name to print it only if it's not null?

easy

A. name?.let { println(it) }

B. let(name) { println(it) }

C. name.let { println(it) }

D. name.let? { println(it) }

Solution

1. Step 1: Recognize nullable safe call usage

   To safely call let only when name is not null, use the safe call operator ?..

2. Step 2: Check syntax correctness

   name?.let { println(it) } runs the block only if name is not null, printing the value.

3. Final Answer:

   name?.let { println(it) } -> Option A

4. Quick Check:

   Safe call with let = name?.let { ... } [OK]

Hint: Use ?.let to run code only if variable is not null [OK]

Common Mistakes:

• Using let without safe call on nullable variable
• Incorrect syntax like let(name) or let? after variable
• Forgetting the safe call operator

3. What is the output of the following Kotlin code?

val number = 5
val result = number.let { it * 2 }
println(result)

medium

A. 10

B. 5

C. it * 2

D. Compilation error

Solution

1. Step 1: Understand the let block execution

   The variable number is 5. The let block multiplies it (which is 5) by 2.

2. Step 2: Calculate the result and print

   The expression it * 2 evaluates to 10, which is assigned to result and printed.

3. Final Answer:

   10 -> Option A

4. Quick Check:

   5 * 2 = 10 [OK]

Hint: let returns block result, so 5 * 2 = 10 [OK]

Common Mistakes:

• Thinking let returns original object
• Confusing it with string output
• Expecting syntax error due to block

4. Identify the error in this Kotlin code snippet using let:

val text: String? = null
text.let { println(it.length) }

medium

A. Prints 'null' string

B. No error, prints 0

C. Compilation error due to missing safe call

D. NullPointerException at runtime

Solution

1. Step 1: Analyze nullable variable usage

   The variable text is nullable and assigned null. Calling let directly runs the block even if text is null.

2. Step 2: Understand runtime behavior

   Inside the block, it.length is accessed. Since it is null, this causes a NullPointerException at runtime.

3. Final Answer:

   NullPointerException at runtime -> Option D

4. Quick Check:

   Accessing length on null causes runtime error [OK]

Hint: Use ?.let to avoid null pointer errors [OK]

Common Mistakes:

• Assuming let skips block if null without safe call
• Expecting compile error instead of runtime error
• Thinking it prints 'null' string

5. Given a nullable list of integers val numbers: List<Int>? = listOf(1, 2, 3), how can you use let to safely calculate and print the sum only if the list is not null and not empty?

hard

A. numbers.let { println(it.sum()) }

B. numbers.let { if (it.isNotEmpty()) println(it.sum()) }

C. numbers?.let { if (it.isNotEmpty()) println(it.sum()) }

D. numbers?.let { println(it.sum()) }

Solution

1. Step 1: Use safe call to handle null list

   Since numbers is nullable, use ?.let to run code only if it's not null.

2. Step 2: Check for empty list inside let block

   Inside the block, check it.isNotEmpty() to ensure the list has elements before summing.

3. Step 3: Print sum only if conditions met

   If the list is not empty, print the sum using println(it.sum()).

4. Final Answer:

   numbers?.let { if (it.isNotEmpty()) println(it.sum()) } -> Option C

5. Quick Check:

   Safe call + empty check + sum print = numbers?.let { if (it.isNotEmpty()) println(it.sum()) } [OK]

Hint: Combine ?.let with isNotEmpty() check inside block [OK]

Common Mistakes:

• Not using safe call on nullable list
• Skipping empty check causing wrong output
• Using let without safe call causing runtime error