Kotlin 标准函数和静态方法

Kotlin中提供了很多标准函数和静态方法，标准函数包括 let、with、run、apply 和 also 等，这些函数主要用于简化对象操作，静态方法则常用于工具类中定义一些不依赖于实例的通用方法。合理使用这些函数和方法，一方面能提高代码的可读性，另一方面对我们的工作效率也很有帮助，本文将对常用的标准函数和静态方法以及他们常见的使用场景进行简单的总结归纳。

Kotlin 标准函数

let函数

let 函数接收一个Lambda表达式作为参数，并将调用该函数的对象作为Lambda表达式的参数传入。在Lambda表达式中，可以对该对象进行操作，并返回最后一行的结果，通常适用于对一个非null对象进行操作。

以开发一个用户注册系统为例，在用户输入信息后，我们需要对输入的数据进行多个验证操作。在每个验证操作之前，我们都需要检查输入值是否为null。首先明确需求，

1.检查任务对象是否为null。

2.如果不为null，显示任务详情。

3.如果为null，显示错误信息。

明确完需求我们开始实现，我们可以先尝试用常规方法用'if'语句实现

val username: String? = getUsernameInput()
val email: String? = getEmailInput()
val password: String? = getPasswordInput()

if (username != null) {
    if (username.length < 6) {
        showError("Username must be at least 6 characters long")
    } else {
        if (email != null) {
            if (!email.contains("@")) {
                showError("Invalid email address")
            } else {
                if (password != null) {
                    if (password.length < 8) {
                        showError("Password must be at least 8 characters long")
                    } else {
                        registerUser(username, email, password)
                    }
                } else {
                    showError("Password is required")
                }
            }
        } else {
            showError("Email is required")
        }
    }
} else {
    showError("Username is required")
}

 可以看到由于每次检查对象是否为null时都需要嵌套 if 语句，这让最终写出来的代码非常冗长且重复，并且嵌套的 if 语句使得代码逻辑难以追踪和理解，更严重的是，如果报错了，错误处理都需要在不同的嵌套层次中进行，这让后期的维护难以进行。

这里我们可以使用 let 函数来简化这一逻辑。

val username: String? = getUsernameInput()
val email: String? = getEmailInput()
val password: String? = getPasswordInput()

username?.let { uname ->
    if (uname.length < 6) {
        showError("Username must be at least 6 characters long")
    } else {
        email?.let { mail ->
            if (!mail.contains("@")) {
                showError("Invalid email address")
            } else {
                password?.let { pwd ->
                    if (pwd.length < 8) {
                        showError("Password must be at least 8 characters long")
                    } else {
                        registerUser(uname, mail, pwd)
                    }
                } ?: showError("Password is required")
            }
        } ?: showError("Email is required")
    }
} ?: showError("Username is required")

 对比 if 语句嵌套， let 函数让代码结构更加扁平和简洁，错误处理也集中在 let 函数的else分支中，这对于后期维护更加友好。

run 函数

run 函数在某个对象上调用，并接受一个 Lambda 表达式作为参数。与 let 函数类似，它也可以减少嵌套，但其返回值是 Lambda 表达式中的最后一行代码的结果。

还是前面的用户注册系统，我们需要创建一段用户活动的日志，并将其保存到文件中。run 函数可以帮助我们简化日志的生成和保存过程。

val logContent = StringBuilder().run {
    append("用户注册成功.\n")
    append("用户登录.\n")
    append("用户退出.\n")
    toString()  // run 函数的返回值是 Lambda 表达式的最后一行代码的结果
}

saveLogToFile(logContent)

run 函数在 StringBuilder 对象上直接进行操作，并返回最终结果，减少了中间变量，所有操作集中在一个表达式中，代码也更加紧凑。

with函数

with 函数用于对某个对象进行一系列操作，并返回 Lambda 表达式的结果。它适用于需要对对象进行多次操作并最终返回某个计算结果的场景。以用户信息管理模块为例，其中我们需要创建一个用户对象，并对其进行一系列的设置和操作，如初始化设置、配置偏好以及记录用户信息。

// 创建用户对象
val user = User(name, age, email)

// 初始化用户对象的额外信息
user.initializeSettings()
user.setupPreferences()

// 记录用户信息
logUserInfo(user)

// 将用户对象传递给其他组件
processUser(user)

由于每个操作分开处理，代码显得比较分散，并且每个操作都需要单独调用看起来比较复杂，用with函数可以集中处理所有操作，使得所有对对象的操作都在一个块中完成。

val user = User(name, age, email).apply {
    initializeSettings()
    setupPreferences()
}.also {
    logUserInfo(it)
}

processUser(user)

also函数

相同场景下also函数也是类似的用法

val user = User(name, age, email).also {
    it.initializeSettings()
    it.setupPreferences()
    logUserInfo(it)
}

// 将用户对象传递给其他组件
processUser(user)

apply函数

apply函数通常用在对象有多个属性需要设置情况下，比如绝大多数应用都有的设置模块，用户根据需要，调整主题、语言和通知偏好。

// 创建并配置 Settings 对象
val settings = Settings().apply {
    theme = "Dark"
    language = "English"
    notificationsEnabled = true
}

// 使用配置的 Settings 对象
applySettings(settings)

apply 函数允许我们在一个代码块中对 Settings 对象进行多个配置操作

静态方法

回到用户注册系统上来，我们常常需要对用户信息进行验证，例如检查用户名是否符合规定的格式，密码是否足够强等等。为了简化这些验证逻辑，我们可以使用一个工具类，其中包含一些静态方法来处理这些验证任务。

// 使用伴生对象中的静态方法
class UserValidator private constructor() {
    companion object {
        fun isValidUsername(username: String): Boolean {
            return username.length in 3..20 && username.all { it.isLetterOrDigit() }
        }

        fun isValidPassword(password: String): Boolean {
            return password.length >= 8 && password.any { it.isDigit() } && password.any { it.isUpperCase() }
        }
    }
}

fun registerUser(username: String, password: String) {
    if (!UserValidator.isValidUsername(username)) {
        println("Invalid username. It should be 3-20 characters long and contain only letters and digits.")
        return
    }

    if (!UserValidator.isValidPassword(password)) {
        println("Invalid password. It should be at least 8 characters long, contain at least one digit and one uppercase letter.")
        return
    }

    // 继续执行注册操作
    println("User registration successful!")
}

fun main() {
    registerUser("JohnDoe", "Password123")  // 注册成功
    registerUser("Jo", "password")          // 用户名和密码都无效
}

用 Kotlin 的伴生对象来定义这些静态方法，可以让这些方法能够在没有实例化工具类的情况下直接调用。这种做法不仅使代码更加简洁，也让将验证逻辑组织得更加清晰。