Location>code7788 >text

Learn Kotlin grammar (IV)

Popularity：504 ℃/2025-04-02 14:31:44

Introduction

In the previous section, we have a general understanding of the relevant knowledge of functions in Kotlin. In this chapter, we will learn about some scope functions in Kotlin.

Table of contents

  1. let: handle nullable objects, chain operations
  2. run: Object configuration + calculate return value
  3. with: Perform multiple operations on non-empty objects
  4. apply: Initialize object configuration
  5. Also: Attached operations (such as printing logs)

The scope functions in Kotlin arelet、run、with、apply、also, They can simplify operations on objects and make the code simpler

let: Process nullable objects, chain operations

In Kotlin,letFunction passes withSafe call operator?.Use in conjunction to gracefully handle nullable objects. The following is a detailed explanation:

  1. Let's Basics of Handling Nullable Objects

    • Syntax structure:Empty object?.let{ ... }

    • Key mechanisms:

      • If the objectNot empty，?.Will triggerletCode block execution, object as parameter (defaultit) Pass to lambda

      • If the objectEmpty，?.Will skipletCode block, the entire expression returnsnull, and the code in lambdaWill not execute

        fun main() {
     val nullableString: String? = "Hello" // Declare after the type ? as a nullable object
     val length = nullableString?.let {
         println("Execution let: The object is not empty, the content is $it") // It will be printed only when it is not empty Output: Execution let: The object is not empty, the content is Hello
          // Return length (result of the last expression)
     }
     println("String length: $length") // Output: String length: 5

     // When the object is empty
     val nullString: String? = null
     val nullResult = nullString?.let {
         println("Because the object is empty, it will not be executed here") // Skipped
        
     }
     println("The result of an empty object is: $nullResult") // Output: The result of an empty object is: null

 }

  2. If the security caller is omitted?.(Error demonstration)

    Call directlylet(Not added?.) May cause null pointer exception (NPE)

    fun main() {
     val str: String? = null
      { // Compilation warning: NPE may be thrown here!
         println(it!!.length) // If str is null,
     }
 }
 /**
  * Exception in thread "main"
  * at (:4)
  * at ()
  * */

    So it must be used?.letHandle nullable objects

  3. Chain operation and default value processing

    CombinedElvis operator?:, can beletThe return result provides default values:

    fun main() {
     val input: String? = null
     val processed = input?.let {
         () // Convert to capitalization when non-empty
     } ?: "DEFAULT" // How to return 'DEFAULT' for input to null
     println(processed) // Output: DEFAULT
 }

  4. Classic usage scenarios

    • Avoid empty check nesting

      data class User(val name: String = "")

 fun main() {
     val user = User("NPC")
     // Traditional air inspection (cumbersome)
     if (user != null) {
         if ( != null) {
             println() // Output: 3
         }
     }
     // Use ?.let (concise)
     user?.name?.let { println() } // Output: 3
 }

    • Data conversion

      fun main() {
     val number: Int? = "123".toIntOrNull()

     println(number) // Output: 123

     val squared = number?.let { it * it } // Compute squared when non-null, otherwise return null

     println(squared) // Output: 15129
 }

    • Side effect operations (such as printing logs)

      fun main() {
     val data = "Hello Kotlin"
     data?.let {
         println("process data: $it")
     }
 }

run: Object configuration + calculate return value

In Kotlin,runis a flexible scope function, which comes in two forms:Extended functionsandNon-extended functions. Its core purpose isExecute code blocks in the context of an object,andReturns the result of the lambda expression. The following isrunDetailed explanation

  1. Two forms of run

    • Form 1: Extended function (object reference)

      Object.run {
     // Code block: access object through this
     // The last line is used as the return value
 }

      • Context: Used in codethisReference object (can be omitted)

      • Return value: the last line result of lambda

    • Form 2: Non-extended functions (independent scope)

      run {
     // Independent code block (no object required)
     // The last line is used as the return value
 }
      • Purpose: Create a temporary scope to avoid variables from contaminating the external environment

  2. Sample code

    • Extend function (operate with object and return result)

      existCarConfigure properties in the object context and return a string describing the state.

      data class Car(var speed: Int = 0, var isEngineOn: Boolean = false)

 fun main() {
     val carStatus = Car().run {
          = 100 // Direct access to the attribute (this can be omitted)
         isEngineOn = true // Modify the object state
         "Car speed: $speed km/h, engine status: ${if (isEngineOn) "Open" else "Off"}" // Return string
     }

     println(carStatus) // Output: Vehicle speed: 100 km/h, Engine status: On
 }

    • Handle nullable objects (combined with empty secure calls?.run)

      Execute code blocks only when the object is not empty, avoiding null pointer exceptions.

      fun printLengthIfNotNull(input: String?) {
     input?.run {
         println("String content: $this, length: $length") // this refers to the input object
     } ?: println("Input is empty")
 }
 fun main() {
     printLengthIfNotNull("Hello, Kotlin") // Output: String content: Hello, Kotlin, Length: 13
     printLengthIfNotNull(null) // Output: Input is empty
 }

    • Non-extended form (independent scope)

      Encapsulate temporary calculation logic to avoid variablesaandbLeak to external scope.

      fun main() {
     val result = run {
         val a = 10
         val b = 20
         a + b // Return the calculation result
     }
     println("calculation result: $result") // Output: Calculation result: 30
 }

  3. Advanced Usage

    • Chained calls multiplerun

      fun main() {
     val message = "Kotlin"
         .run { uppercase() } // Convert to uppercase
         .run { "Message: $this" } // Add prefix
     println(message) // Output: Message: KOTLIN
 }

    • andapplyUse in combination

      data class Config(var host: String = "", var port: Int = 0)

 fun main() {
     val config = Config().apply {
         host = "127.0.0.1" // Initialize the configuration
         port = 8080
     }.run {
         "Server address: $host:$port" // Convert to a connection string
     }
     println(config) // Output: Server address: 127.0.0.1:8080
 }

apply: Initialize object configuration

In Kotlin,applyis a commonly used scope function.Specially used for initialization or configuration of objects. It allows you to complete the setting of object properties in a code block through concise syntax and ultimately return to the object itself. The following isapplyDetailed explanation

  1. Basic syntax

    val object = original object.apply {
     // Configure the properties of the object or call the method here
      = value // this can be omitted
     method()
     // ...
 }
 // apply Return to the original object and can continue operation

  2. Sample code

    • Initialize object properties

      data class Person(var name: String = "", var age: Int = 0)

 fun main() {
     val person = Person().apply {
         name = "Alice" // equivalent to = "Alice"
         age = 30 // Direct access to attributes, this can be omitted
     }
     println(person) // Output: Person(name=Alice, age=30)
 }

    • Chain configuration multiple attributes

      class Car {
     var brand: String = ""
     var speed: Int = 0
     fun start() { println("$brand start, speed: $speed km/h") }

 }
 fun main() {
     var car = Car()
         .apply { brand = "XiaoMi SU7" }
         .apply { speed = 200 }
         .apply { start() } // Output: XiaoMi SU7 Start, speed: 200 km/h
 }

    • Alternative Builder mode

      // Traditional Builder mode vs apply simplification
 class Dialog {
     var title: String = ""
     var message: String = ""

     fun show() { println("Show dialog: $title - $message") }
 }

 fun main() {
     // Traditional way
     val dialog1 = Dialog()
      = "Tip"
      = "Welcome to Kotlin"
     ()

     // Use apply (more simpler)
     val dialog2 = Dialog().apply {
         title = "Tip"
         message = "Welcome to Kotlin"
         show() // Directly call the method
     }
 }

    • Handle nullable objects

      fun configureNullableObject() {
     val nullableConfig: String? = null
     nullableConfig?.apply {
         println("Configure non-empty object: $this") // will not be executed here
     } ?: println("Object is empty") // Output: The object is empty
 }

 fun main() {
     configureNullableObject()
 }

  3. Common Mistakes

    • Error: InapplyReturns other values

      data class Person (var name: String = "",var age: Int = 0)

 fun main() {
     val person = Person().apply {
         name = "Bob"
         "This is an error example" // This line of code is invalid
     }
     println(person)
 }

    • The correct way is: If you need to return the calculation result, you should use itrun：

      data class Person (var name: String = "",var age: Int = 0)

 fun main() {
     val person = Person().run {
         name = "Bob"
         "Name: $name"
     }
     println(person) // Output: Name: Bob
 }

  4. Advanced Usage

    • Chained calls to multiple scope functions

      data class File(var absolutePath: String = "") {
     fun readText() {
         // ... Read file operation
         println("Read File Operation")
     }
 }

 fun createNewFile() {
     // ... Create file operation
     println("Create file operation")
 }
 fun main() {
     File("")
         .apply { createNewFile() }
         .also { println("File Path: ${}") }
         .readText()
 }

    • CombinedtakeIfFilter conditions

      data class Person(var name: String = "", var age: Int = 0)
 fun main() {
     val validPerson = Person().apply {
         name = "Charlie"
         age = 25
     }.takeIf {  >= 18 } // Only adults are retained
     println(validPerson) // Output: Person(name=Charlie, age=25)
 }

with: Perform multiple operations on non-empty objects

In Kotlin,withis a scope function,Used to perform multiple operations on existing objects, it uses the object as context (this) Pass it into the code block to make the code more centralized and easier to read. The following iswithDetailed explanation

  1. Basic syntax

    val result = with(object) {
     // Direct access to the object's properties and methods here (this can be omitted)
     Operation 1
     Operation 2
     ...
     The last line is used as the return value
 }

  2. Sample code

    • Batch operation object properties

      data class User(var name: String = "", var age: Int = 0)

 fun main() {
     val user = User("Alice", 25)
     val info = with(user) {
         name = "Bob" // equivalent to = "Bob"
         age += 5 // Modify properties
         "After update: $name, $age age" // Return string
     }
     println(info) // Output: Updated: Bob, 30 years old
     println(user) // Output: User(name=Bob, age=30)
 }

    • Perform calculation and return results

      class Rectangle(val width: Int, val height: Int) {
     fun area() = width * height
 }

 fun main() {
     val rect = Rectangle(10, 20)
     val result = with(rect) {
         val perimeter = 2 * (width + height) // Access properties
         "Area: ${area()}, Perimeter: $perimeter" // Call the method and return the string
     }
     println(result) // Output: Area: 200, Perimeter: 60
 }

    • Process collection operations

      fun main() {
     val numbers = listOf(1, 2, 3, 4, 5)
     val summary = with(numbers) {
         val sum = sum()
         val avg = average()
         "Sum: $sum, Average: $avg" // Return statistical results
     }
     println(summary) // Output: Sum: 15, Average: 3.0
 }

  3. Common Mistakes

    • Error: Use it directly on nullable objectswith

      data class Person(var name: String = "", var age: Int = 0)

 fun main() {
     val person: Person? = null
     with(person) {
         println(name) // Compile error Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type Person?
     }
 }

    • The correct way to do it

      data class Person(var name: String = "", var age: Int = 0)

 fun main() {
     val user: Person? = null
     with(user ?: return) { // If user is null, exit early
         println(name)
     }
 }

  4. Classic application scenarios

    • Configuring object properties centrally

      data class Person(var name: String = "", var age: Int = 0) {
     fun sout() {
         println("Name: $name, Age: $age")
     }
 }

 fun main() {
     val person = Person()
     with(person) {
         name = "NPC"
         age = 24
         sout() // Output: Name: NPC, Age: 24
     }

 }

    • Data conversion and calculation

      fun main() {
     val list = listOf(1, 2, 3)
     val squaredSum = with(list) {
         map { it * it }.sum()
     }
     println(squaredSum) // Output: 14
 }

    • Simplify multi-step operation

      data class File(var fileName: String ="") {
     fun createNewFile() {
         println("Create file $fileName")
     }
     fun exists(): Boolean {
         println("Judge whether the $fileName file exists")
         return false
     }
     fun readText(): String {
         return "Read file $fileName"
     }
 }

 fun main() {
     val file = File("")
     val content = with(file) {
         if (!exists()) createNewFile()
         readText().uppercase()
     }
     println(content) // Output: Read the file
 }

also: Additional operations (such as printing logs)

In Kotlin,alsois a scope function,Focus on performing additional operations (such as logging, verification, debugging), while preserving the object itself and supporting chain calls. It does not modify the object, but allows insertion of "side effects" in the object operation flow. The following isalsoDetailed explanation

  1. Basic syntax

    val object = original object.also {
     // Access the object through it and perform additional operations
     // Return the original object (regardless of what is done in the code block)
 }

  2. Sample code

    • Print log (debug intermediate state)

      data class User(var name: String, var age: Int)

 fun main() {
     val user = User("Alice", 25)
         .also { println("Initialized: $it") } // Output: After initialization: User(name=Alice, age=25)
         .apply { age += 5 }
         .also { println("After modifying age: $it") } // Output: After modifying age: User(name=Alice, age=30)

     println("final result: $user") // Output: Final result: User(name=Alice, age=30)
 }

    • Data Verification

      fun processOrder(order: Order?) {
     order?.also {
         require( > 0) { "The order amount must be greater than 0" }
         requireNotNull() { "The order must have customer information" }
     }?.also {
         println("Start the order processing: ${}") // Execute after verification is passed
     }
 }

 data class Order(val id: String, var amount: Double, var customer: String?)

 fun main() {
     val validOrder = Order("123", 100.0, "Alice")
     processOrder(validOrder) // Output: Start processing order: 123

     val invalidOrder = Order("456", -50.0, null)
     processOrder(invalidOrder) // Throw IllegalArgumentException
 }

    • Insert operation in chain call

      fun main() {
     val list = mutableListOf(1, 2, 3)
         .also { (4) } // Add element
         .also { (0) } // Delete the first element (actually no 0, this operation is a demonstration)
         .also { println("Current List: $it") } // Output: Current List: [2, 3, 4]

     println(list) // Output: [2, 3, 4]
 }

  3. Common Mistakes

    • Error:alsoTry to return another value

      data class User(var name: String, var age: Int)

 fun main() {
     // mistake!  also always return the original object, ignoring the return value in the code block
     val user = User("Alice", 25).also {
         "Invalid return value" // This line of code is meaningless
     }
     println(user) // Output: User(name=Alice, age=25)
 }

    • Correct way: If you need to return the calculation result, you should useletorrun

      data class User(var name: String, var age: Int)

 fun main() {
     val info = User("Alice", 25).let {
         "${}' age is ${}" // Returns the string
     }
     println(info) // Output: Alice's age is 25
 }

  4. Advanced Usage

    • CombinedtakeIfPerform conditional filtering

      data class User(var name: String, var age: Int)

 fun createUser(name: String?, age: Int): User? {
     return name?.let {
         User(it, age)
     }?.takeIf { >= 18 } // Only adults are retained
         ?.also { println("User creation successfully: $it") } // Logging
 }

 fun main() {
     val user = createUser("Bob", 20) // Output: User creation successfully: User(name=Bob, age=20)
     println(user) // Output: User(name=Bob, age=20)
 }

    • Tracking the process during the collection operation

      fun main() {
     val numbers = (1..10)
         .filter { it % 2 == 0 }
         .also { println("Filtered even number: $it") } // Output: Filtered even number: [2, 4, 6, 8, 10]
         .map { it * it }
         .also { println("Square result: $it") } // Output: Square result: [4, 16, 36, 64, 100]
 }

Core comparison table

function Context object reference Return value Typical scenarios Air security support
let it Lambda results Empty object processing, data conversion Need to cooperate?.（object?.let）
run this Lambda results Object configuration + return result calculation, independent scope Need to cooperate?.（object?.run）
apply this The object itself Object initialization (chain configuration properties) Need to cooperate?.（object?.apply）
with this Lambda results Batch operations on existing non-empty objects Need to handle the air security by yourself
also it The object itself Additional operations (logs, verifications), intermediate operations in chain calls Need to cooperate?.（object?.also）

  • Context object reference

    data class Car(var speed: Int = 0) {
     fun accelerate() { speed += 10 }
 }

 fun main() {
     val car = Car().apply {
         speed = 100 // Direct access to the attribute (this can be omitted)
         accelerate() // Directly call the method
     }
     println(car) // Output: Car(speed=110)
 }

  • it(Show reference):let 、also

    fun main() {
     val list = mutableListOf(1, 2, 3)
         .also { (4) } // Explicitly use it
         .let { ("-") } // Convert to a string
     println(list) // Output: 1-2-3-4
 }

  • Return to the object itself:apply 、also

    data class Button(var text: String = "", var textSize: Float = 0.0f)

 fun main() {
     // apply Returns the object itself, suitable for chain configuration
     val button = Button().apply {
         text = "Submit"
         textSize = 16f
     }
     // also returns the object itself, suitable for inserting additional operations
      { println("button configured: $it") } // Output: Button configured: Button(text=Submit, textSize=16.0)

 }

  • Returns Lambda results:let 、run 、also

    data class Car(var speed: Int = 0) {
     fun accelerate() { speed += 10 }
 }

 fun main() {
     // let return converted data
     val length = "Kotlin".let { }

     println(length) // Output: 6

     // run Returns the calculation result
     val area = Car(200).run { speed * 2 }

     println(area) // Output: 400

     // with Return the processed result
     val info = with(Car()) {
         speed = 100
         "Speed: $speed km/h"
     }
    
     println(info) // Output: Vehicle speed: 100 km/h
 }

  • Need to cooperate?. : let 、run 、 apply 、 also

    fun main() {
     val nullableString: String? = null

     nullableString?.let {
         println() // Execute when non-empty
     } ?: println("String is empty")

     nullableString?.apply {
         println(length) // Execute when non-empty
     }
 }

  • Need to handle it yourself:with

    data class User(var name: String = "", var age: Int = 0)

 fun main() {
     val user: User? = User()
     user?.let {
         with(it) { // Make sure to use with after non-empty
             name = "Alice"
             age = 30
         }
     }
     println(user) // Output: User(name=Alice, age=30)
 }

Selection Guide

  1. Is it necessary to return the object itself?
    • Yes →applyoralso(Depending on whether it is necessary to explicitlyit）。
    • No →let、run、with(Depending on whether it is necessary to implicitlythis）。
  2. Do I need to deal with nullable objects?
    • Yes →?.let、?.run、?.apply、?.also。
    • No →withOr use other functions directly.
  3. Is it necessary to have intermediate operations in chained calls?
    • Yes →also(such as logging).
    • No → Select according to the return value requirement.

Mixed use examples

// Chain call: initialization, verification, conversion
 data class Product(var name: String = "", var price: Double = 0.0)

 fun main() {
     val productInfo = Product()
         .apply {
             name = "Mobile phone"
             price = 2999.0
         }
         .also {
             require( > 0) { "The price must be greater than 0" }
             println("Product Initialized: $it")
         }
         .let {
             "${} Price: ${} Yuan" // Return string
         }

     println(productInfo) // Output: Mobile Phone Price: 2999.0 yuan
 }
<Previous Next>