String templates and interpolation in Kotlin - Step-by-Step Execution

Concept Flow - String templates and interpolation

Start

↓

Define variables

↓

Create string with $variable

↓

Evaluate expression inside ${}

↓

Replace placeholders with values

↓

Final string ready

↓

Print or use string

↓

End

This flow shows how Kotlin replaces variables and expressions inside strings with their actual values to create the final string.

Execution Sample

Kotlin

val name = "Anna"
val age = 25
val greeting = "Hello, $name! You are ${age + 1} years old."
println(greeting)

This code creates a greeting string using variables and an expression inside the string, then prints it.

Execution Table

Step	Action	Evaluation	Result
1	Define variable name	name = "Anna"	name = "Anna"
2	Define variable age	age = 25	age = 25
3	Create string with templates	"Hello, $name! You are ${age + 1} years old."	Placeholders found: $name and ${age + 1}
4	Replace $name with value	$name -> "Anna"	"Hello, Anna! You are ${age + 1} years old."
5	Evaluate expression ${age + 1}	age + 1 = 26	"Hello, Anna! You are 26 years old."
6	Print final string	println(...)	Output: Hello, Anna! You are 26 years old.
7	End	No more actions	Execution complete

💡 All placeholders replaced and string printed, program ends.

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
name	undefined	"Anna"	"Anna"	"Anna"
age	undefined	undefined	25	25
greeting	undefined	undefined	undefined	"Hello, Anna! You are 26 years old."

Key Moments - 2 Insights

Why do we use ${} inside the string instead of just $ for expressions?

The ${} syntax tells Kotlin to evaluate the expression inside it, like age + 1, while $ alone is only for simple variable names. See execution_table rows 3, 4, and 5.

What happens if we forget to use $ before a variable inside the string?

Without $, Kotlin treats it as normal text, not a variable. So the variable name won't be replaced. This is shown in execution_table row 3 where placeholders are detected.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of greeting after step 5?

A "Hello, Anna! You are 26 years old."

B "Hello, $name! You are ${age + 1} years old."

C "Hello, Anna! You are ${age + 1} years old."

D "Hello, $name! You are 26 years old."

💡 Hint

Check execution_table row 5 where expression is evaluated and placeholders replaced.

At which step does Kotlin replace the $name placeholder with its value?

A Step 2

B Step 4

C Step 5

D Step 6

💡 Hint

Look at execution_table row 4 where $name is replaced.

If age was 30 instead of 25, what would be the output after step 6?

A Hello, Anna! You are 25 years old.

B Hello, Anna! You are 30 years old.

C Hello, Anna! You are 31 years old.

D Hello, Anna! You are 26 years old.

💡 Hint

Check how expression ${age + 1} is evaluated in execution_table row 5.

Concept Snapshot

String templates use $variable or ${expression} inside strings.
Kotlin replaces these with actual values when creating the string.
Use $ for simple variables, ${} for expressions.
This makes string building easy and readable.
Example: "Hello, $name! You are ${age + 1} years old."

Full Transcript

This visual trace shows how Kotlin handles string templates and interpolation. First, variables name and age are defined. Then a string greeting is created with placeholders $name and ${age + 1}. Kotlin replaces $name with "Anna" and evaluates the expression age + 1 to 26, replacing ${age + 1}. Finally, the complete string "Hello, Anna! You are 26 years old." is printed. This process helps build strings easily by embedding variables and expressions directly inside them.

Practice

1. What is the correct way to include a variable name inside a Kotlin string using string templates?

easy

A. println("Hello, +name+")

B. println("Hello, {name}!")

C. println("Hello, $name!")

D. println("Hello, %name%!")

Solution

1. Step 1: Understand Kotlin string templates

   Kotlin uses $variable to insert variable values inside strings.

2. Step 2: Identify correct syntax for variable insertion

   The syntax $name directly inserts the value of name into the string.

3. Final Answer:

   println("Hello, $name!") -> Option C

4. Quick Check:

   Use $variable for string templates [OK]

Hint: Use $variable to insert variables inside strings [OK]

Common Mistakes:

• Using curly braces without $ like {name}
• Concatenating with + inside strings
• Using % signs instead of $

2. Which of the following is the correct syntax to include an expression inside a Kotlin string template?

easy

A. println("Sum is ${a + b}")

B. println("Sum is $a + $b")

C. println("Sum is $[a + b]")

D. println("Sum is $(a + b)")

Solution

1. Step 1: Recall expression syntax in string templates

   Kotlin uses ${expression} to evaluate expressions inside strings.

2. Step 2: Identify correct expression usage

   ${a + b} correctly calculates the sum and inserts it.

3. Final Answer:

   println("Sum is ${a + b}") -> Option A

4. Quick Check:

   Use ${expression} for calculations inside strings [OK]

Hint: Use ${} to insert expressions inside strings [OK]

Common Mistakes:

• Using $a + $b prints variables separately, not sum
• Using square brackets [] instead of curly braces
• Using parentheses () without $

3. What will be the output of the following Kotlin code?

val price = 10
val tax = 2
println("Total: ${price + tax}")

medium

A. Total: 10 + 2

B. Total: 12

C. Total: ${price + tax}

D. Total: price + tax

Solution

1. Step 1: Evaluate the expression inside the string template

   The expression ${price + tax} adds 10 + 2 = 12.

2. Step 2: Print the resulting string

   The string becomes "Total: 12" and is printed.

3. Final Answer:

   Total: 12 -> Option B

4. Quick Check:

   Expression inside ${} is evaluated [OK]

Hint: Expressions inside ${} are calculated before printing [OK]

Common Mistakes:

• Printing the expression literally without evaluation
• Confusing $variable with ${expression}
• Expecting concatenation without braces

4. Identify the error in this Kotlin code snippet:

val count = 5
println("Count is $count+1")

medium

A. It will print 'Count is 5+1' literally, not sum

B. Runtime error because of invalid string

C. Syntax error due to missing braces

D. It will print 'Count is 6' correctly

Solution

1. Step 1: Understand how $count+1 is interpreted

   Kotlin treats $count as variable and +1 as plain text, so it prints "5+1" literally.

2. Step 2: Correct way to calculate sum in string

   Use ${count + 1} to evaluate the sum inside the string.

3. Final Answer:

   It will print 'Count is 5+1' literally, not sum -> Option A

4. Quick Check:

   Use ${} for expressions, else prints text [OK]

Hint: Use ${} to calculate expressions, else prints text [OK]

Common Mistakes:

• Assuming $count+1 calculates sum automatically
• Missing braces for expressions
• Confusing string concatenation with templates

5. You want to print the price with a dollar sign, for example: $20. Which Kotlin string correctly shows the dollar sign before the number stored in price?

hard

A. println("$price")

B. println("\$price")

C. println("$\$price")

D. println("\$$price")

Solution

1. Step 1: Understand escaping dollar sign in Kotlin strings

   To print a literal dollar sign, use \$ to escape it.

2. Step 2: Combine escaped dollar sign with variable

   "\$$price" prints a literal $ followed by the value of price.

3. Final Answer:

   println("\$$price") -> Option D

4. Quick Check:

   Escape $ with \$ to print it literally [OK]

Hint: Escape $ as \$ to print dollar sign literally [OK]

Common Mistakes:

• Not escaping $ prints variable name or causes error
• Using $\$ instead of \$$
• Confusing escape sequences