Kotlin 条件控制：从基础到实战的完整指南

最新推荐文章于 2026-08-17 17:20:16 发布

原创最新推荐文章于 2026-08-17 17:20:16 发布 · 222 阅读

本内容遵循CC 4.0 BY-SA版权协议

1. 引言

条件控制是任何编程语言的核心基础，它决定了程序在不同场景下的执行路径。Kotlin 作为一门现代化的 JVM 语言，在条件控制方面既保留了传统语言的经典结构，又引入了许多简洁、安全且富有表达力的新特性。本文将深入探讨 Kotlin 中的各种条件控制语句，包括 if、when、范围检查、空安全控制等，并通过丰富的代码实例展示其在实际开发中的应用。

2. 基础条件语句：if-else

Kotlin 中的 if 语句既可以作为传统的流程控制语句，也可以作为表达式使用，这为代码的简洁性提供了更多可能。

2.1 传统 if-else 语句

fun checkNumber(num: Int) {
    if (num > 0) {
        println("$num 是正数")
    } else if (num < 0) {
        println("$num 是负数")
    } else {
        println("数字是 0")
    }
}

fun main() {
    checkNumber(10)   // 输出：10 是正数
    checkNumber(-5)   // 输出：-5 是负数
    checkNumber(0)    // 输出：数字是 0
}

2.2 if 作为表达式

Kotlin 中的 if 可以返回一个值，这使得代码更加简洁：

fun max(a: Int, b: Int): Int {
    return if (a > b) a else b
}

// 更简洁的写法
fun min(a: Int, b: Int) = if (a < b) a else b

fun main() {
    println("最大值：${max(5, 10)}")  // 输出：最大值：10
    println("最小值：${min(5, 10)}")  // 输出：最小值：5
    
    // if-else 表达式可以赋值给变量
    val score = 85
    val grade = if (score >= 90) "A"
                else if (score >= 80) "B"
                else if (score >= 70) "C"
                else if (score >= 60) "D"
                else "F"
    println("分数 $score 的等级是：$grade")  // 输出：分数 85 的等级是：B
}

3. 强大的 when 表达式

when 是 Kotlin 中替代传统 switch 语句的强大工具，它更加灵活且功能丰富。

3.1 基础 when 用法

fun describeNumber(num: Int): String {
    return when (num) {
        1 -> "一"
        2 -> "二"
        3 -> "三"
        else -> "其他数字"
    }
}

fun main() {
    println(describeNumber(2))  // 输出：二
    println(describeNumber(5))  // 输出：其他数字
}

3.2 多条件匹配

fun checkDayType(day: String): String {
    return when (day) {
        "Monday", "Tuesday", "Wednesday", "Thursday", "Friday" -> "工作日"
        "Saturday", "Sunday" -> "周末"
        else -> "无效的日期"
    }
}

fun main() {
    println(checkDayType("Monday"))   // 输出：工作日
    println(checkDayType("Sunday"))   // 输出：周末
    println(checkDayType("Holiday"))  // 输出：无效的日期
}

3.3 范围匹配

fun evaluateScore(score: Int): String {
    return when (score) {
        in 90..100 -> "优秀"
        in 80..89 -> "良好"
        in 70..79 -> "中等"
        in 60..69 -> "及格"
        in 0..59 -> "不及格"
        else -> "无效分数"
    }
}

fun main() {
    println("95分：${evaluateScore(95)}")  // 输出：95分：优秀
    println("75分：${evaluateScore(75)}")  // 输出：75分：中等
    println("55分：${evaluateScore(55)}")  // 输出：55分：不及格
}

3.4 类型检查

fun describeValue(value: Any): String {
    return when (value) {
        is String -> "字符串，长度：${value.length}"
        is Int -> "整数，值：$value"
        is Double -> "双精度浮点数，值：$value"
        is Boolean -> "布尔值，值：$value"
        else -> "未知类型"
    }
}

fun main() {
    println(describeValue("Hello"))      // 输出：字符串，长度：5
    println(describeValue(42))           // 输出：整数，值：42
    println(describeValue(3.14))         // 输出：双精度浮点数，值：3.14
    println(describeValue(true))         // 输出：布尔值，值：true
    println(describeValue(listOf(1,2,3))) // 输出：未知类型
}

3.5 无参 when 表达式

fun checkNumberType(num: Int): String {
    return when {
        num > 0 && num % 2 == 0 -> "正偶数"
        num > 0 && num % 2 != 0 -> "正奇数"
        num < 0 && num % 2 == 0 -> "负偶数"
        num < 0 && num % 2 != 0 -> "负奇数"
        num == 0 -> "零"
        else -> "其他"
    }
}

fun main() {
    println("4: ${checkNumberType(4)}")   // 输出：4: 正偶数
    println("-3: ${checkNumberType(-3)}") // 输出：-3: 负奇数
    println("0: ${checkNumberType(0)}")   // 输出：0: 零
}

4. 空安全与条件控制

Kotlin 的空安全特性与条件控制紧密结合，提供了多种安全处理空值的方式。

4.1 安全调用操作符

data class User(val name: String?, val age: Int?)

fun getUserInfo(user: User?) {
    // 安全调用，如果 user 为 null 则整个表达式返回 null
    val userName = user?.name
    val userAge = user?.age
    
    println("用户名：$userName, 年龄：$userAge")
}

fun main() {
    val user1 = User("Alice", 25)
    val user2: User? = null
    
    getUserInfo(user1)  // 输出：用户名：Alice, 年龄：25
    getUserInfo(user2)  // 输出：用户名：null, 年龄：null
}

4.2 Elvis 操作符

fun getDisplayName(name: String?): String {
    // 如果 name 不为 null 则返回 name，否则返回 "匿名用户"
    return name ?: "匿名用户"
}

fun getLength(str: String?): Int {
    // 安全调用 + Elvis 操作符
    return str?.length ?: 0
}

fun main() {
    println(getDisplayName("Bob"))      // 输出：Bob
    println(getDisplayName(null))       // 输出：匿名用户
    
    println("长度：${getLength("Hello")}")    // 输出：长度：5
    println("长度：${getLength(null)}")       // 输出：长度：0
}

4.3 安全转换

fun parseNumber(str: String?): Int? {
    // 安全转换，如果转换失败则返回 null
    return str?.toIntOrNull()
}

fun main() {
    println(parseNumber("123"))    // 输出：123
    println(parseNumber("abc"))    // 输出：null
    println(parseNumber(null))     // 输出：null
    
    // 结合 when 表达式使用
    val result = when (val num = parseNumber("456")) {
        null -> "转换失败"
        else -> "转换成功：$num"
    }
    println(result)  // 输出：转换成功：456
}

5. 范围检查与区间

Kotlin 的区间表达式可以与条件控制语句完美结合。

fun checkTemperature(temp: Int): String {
    return when {
        temp in 20..25 -> "舒适温度"
        temp in 26..30 -> "温暖"
        temp in 15..19 -> "凉爽"
        temp > 30 -> "炎热"
        temp < 15 -> "寒冷"
        else -> "异常温度"
    }
}

fun validateAge(age: Int): Boolean {
    // 使用 until 创建半开区间
    return age in 18 until 100
}

fun main() {
    println("22度：${checkTemperature(22)}")  // 输出：22度：舒适温度
    println("35度：${checkTemperature(35)}")  // 输出：35度：炎热
    
    println("年龄20是否有效：${validateAge(20)}")  // 输出：年龄20是否有效：true
    println("年龄17是否有效：${validateAge(17)}")  // 输出：年龄17是否有效：false
    println("年龄100是否有效：${validateAge(100)}") // 输出：年龄100是否有效：false
}

6. 实战案例：用户权限检查系统

下面通过一个完整的实战案例，展示 Kotlin 条件控制在真实场景中的应用。

// 定义用户角色枚举
enum class UserRole {
    GUEST, USER, EDITOR, ADMIN, SUPER_ADMIN
}

// 定义权限级别
enum class PermissionLevel {
    NONE, READ, WRITE, DELETE, MANAGE
}

// 用户数据类
data class User(
    val id: String,
    val name: String,
    val role: UserRole,
    val isActive: Boolean = true
)

// 权限检查类
class PermissionChecker {
    
    // 检查用户是否有特定权限
    fun checkPermission(user: User?, requiredPermission: PermissionLevel): Boolean {
        // 空值检查
        if (user == null) return false
        
        // 用户状态检查
        if (!user.isActive) return false
        
        // 根据角色判断权限
        return when (user.role) {
            UserRole.GUEST -> requiredPermission == PermissionLevel.READ
            UserRole.USER -> requiredPermission in listOf(PermissionLevel.READ, PermissionLevel.WRITE)
            UserRole.EDITOR -> requiredPermission in listOf(PermissionLevel.READ, PermissionLevel.WRITE, PermissionLevel.DELETE)
            UserRole.ADMIN -> requiredPermission != PermissionLevel.MANAGE
            UserRole.SUPER_ADMIN -> true
        }
    }
    
    // 获取用户可访问的功能列表
    fun getAccessibleFeatures(user: User?): List<String> {
        return when {
            user == null || !user.isActive -> emptyList()
            user.role == UserRole.GUEST -> listOf("查看文章", "搜索")
            user.role == UserRole.USER -> listOf("查看文章", "搜索", "评论", "收藏")
            user.role == UserRole.EDITOR -> listOf("查看文章", "搜索", "评论", "收藏", "发布文章", "编辑文章", "删除文章")
            user.role == UserRole.ADMIN -> listOf("查看文章", "搜索", "评论", "收藏", "发布文章", "编辑文章", "删除文章", "用户管理", "内容审核")
            user.role == UserRole.SUPER_ADMIN -> listOf("所有功能")
            else -> emptyList()
        }
    }
}

fun main() {
    val checker = PermissionChecker()
    
    // 创建测试用户
    val guest = User("001", "访客", UserRole.GUEST)
    val user = User("002", "普通用户", UserRole.USER)
    val editor = User("003", "编辑", UserRole.EDITOR)
    val admin = User("004", "管理员", UserRole.ADMIN)
    val superAdmin = User("005", "超级管理员", UserRole.SUPER_ADMIN)
    val inactiveUser = User("006", "停用用户", UserRole.USER, false)
    
    // 测试权限检查
    println("访客能否读取：${checker.checkPermission(guest, PermissionLevel.READ)}")      // true
    println("访客能否写入：${checker.checkPermission(guest, PermissionLevel.WRITE)}")     // false
    println("编辑能否删除：${checker.checkPermission(editor, PermissionLevel.DELETE)}")   // true
    println("管理员能否管理：${checker.checkPermission(admin, PermissionLevel.MANAGE)}")  // false
    println("超级管理员能否管理：${checker.checkPermission(superAdmin, PermissionLevel.MANAGE)}") // true
    println("停用用户能否读取：${checker.checkPermission(inactiveUser, PermissionLevel.READ)}") // false
    
    // 测试功能列表
    println("\n普通用户功能：${checker.getAccessibleFeatures(user)}")
    println("管理员功能：${checker.getAccessibleFeatures(admin)}")
}

7. 最佳实践与注意事项

7.1 优先使用 when 替代复杂的 if-else

// 不推荐：复杂的 if-else 链
fun processStatusOld(status: Int): String {
    if (status == 0) return "待处理"
    else if (status == 1) return "处理中"
    else if (status == 2) return "已完成"
    else if (status == 3) return "已取消"
    else return "未知状态"
}

// 推荐：使用 when 表达式
fun processStatusNew(status: Int): String = when (status) {
    0 -> "待处理"
    1 -> "处理中"
    2 -> "已完成"
    3 -> "已取消"
    else -> "未知状态"
}

7.2 利用 when 的表达式特性

// 直接返回 when 表达式的结果
val result = when (val input = readLine()) {
    null -> "输入为空"
    "" -> "输入为空字符串"
    else -> "输入内容：$input"
}

7.3 空安全处理

// 安全处理可为空的变量
fun processUserInput(input: String?) {
    val processed = input?.let { 
        // 仅在 input 不为 null 时执行
        it.trim().uppercase()
    } ?: run {
        // input 为 null 时的处理
        "DEFAULT_VALUE"
    }
    println("处理结果：$processed")
}

8. 总结

Kotlin 的条件控制机制既强大又优雅，通过 if 表达式、when 表达式、空安全操作符等特性，开发者可以编写出更简洁、更安全、更易读的代码。关键要点总结如下：

if 作为表达式：可以返回值，减少临时变量
when 的多功能性：支持值匹配、类型检查、范围匹配等
空安全集成：安全调用、Elvis 操作符与条件控制无缝结合
范围表达式：in、..、until 等操作符简化区间检查
实战应用：在权限系统、状态机、数据验证等场景中发挥重要作用

掌握这些条件控制技巧，将显著提升你的 Kotlin 编程效率和代码质量。

标签

#kotlin #前端 #javascript