控制流

// Java 风格：if 作为语句
var max: Int
if (a > b) {
    max = a
} else {
    max = b
}
 
// Kotlin 风格：if 作为表达式，直接返回值
val max = if (a > b) a else b

val result = if (score >= 60) {
    println("恭喜通过！")
    "Pass"  // 这是返回值
} else {
    println("继续努力！")
    "Fail"  // 这是返回值
}
// result 的类型是 String

val grade = if (score >= 90) {
    val bonus = 10
    "A+ (bonus: $bonus)"  // 返回此字符串
} else if (score >= 80) {
    "B"
} else {
    "C"
}

// ✅ 合法：作为语句，不需要返回值
if (isDebug) {
    println("Debug mode enabled")
}
 
// ❌ 编译错误：作为表达式必须有 else
val message = if (isDebug) "Debug"  
// Error: 'if' must have both main and 'else' branches if used as an expression

┌─────────────────────────────────────────────────────────┐
│           if 表达式的 else 规则                          │
├─────────────────────────────────────────────────────────┤
│  用途              │  是否需要 else  │  原因             │
├───────────────────┼────────────────┼──────────────────┤
│  作为语句 (不赋值)  │     可选       │  不需要返回值      │
│  作为表达式 (赋值)  │     必须       │  必须覆盖所有情况  │
└─────────────────────────────────────────────────────────┘

val ticket = if (age < 18) {
    if (isStudent) "学生票 (半价)" else "未成年票"
} else {
    if (age >= 65) "老年票 (免费)" else "成人票"
}

// Java
String result = condition ? "yes" : "no";
 
// Kotlin（完全等价，且更易读）
val result = if (condition) "yes" else "no"

// Java switch
switch (day) {
    case 1: result = "Monday"; break;
    case 2: result = "Tuesday"; break;
    default: result = "Unknown"; break;
}
 
// Kotlin when（更简洁，无需 break）
val result = when (day) {
    1 -> "Monday"
    2 -> "Tuesday"
    else -> "Unknown"
}

fun getColorHex(color: String): String = when (color) {
    "red" -> "#FF0000"
    "green" -> "#00FF00"
    "blue" -> "#0000FF"
    else -> "#FFFFFF"
}

fun describe(obj: Any): String = when (obj) {
    is String -> "字符串，长度为 ${obj.length}"  // 自动转换为 String
    is Int -> "整数，平方为 ${obj * obj}"        // 自动转换为 Int
    is List<*> -> "列表，大小为 ${obj.size}"     // 自动转换为 List
    else -> "未知类型"
}

fun getGrade(score: Int): String = when (score) {
    in 90..100 -> "A"      // 90 到 100（闭区间）
    in 80 until 90 -> "B"  // 80 到 89（半开区间）
    in 70..79 -> "C"
    in 60..69 -> "D"
    else -> "F"
}
 
// 也可以检查是否在集合中
fun isWeekend(day: String) = when (day) {
    in listOf("Saturday", "Sunday") -> true
    else -> false
}

fun isVowel(char: Char): Boolean = when (char) {
    'a', 'e', 'i', 'o', 'u',
    'A', 'E', 'I', 'O', 'U' -> true
    else -> false
}
 
// 等价于 Java 的 fall-through，但更清晰
fun getQuarter(month: Int): Int = when (month) {
    1, 2, 3 -> 1
    4, 5, 6 -> 2
    7, 8, 9 -> 3
    10, 11, 12 -> 4
    else -> throw IllegalArgumentException("Invalid month: $month")
}

fun classifyTemperature(temp: Int): String = when {
    temp < 0 -> "冰冻 (Freezing)"
    temp < 15 -> "寒冷 (Cold)"
    temp < 25 -> "舒适 (Comfortable)"
    temp < 35 -> "炎热 (Hot)"
    else -> "极端高温 (Extreme)"
}

fun validateUser(user: User): String = when {
    user.name.isBlank() -> "用户名不能为空"
    user.age < 0 -> "年龄不能为负数"
    user.email != null && !user.email.contains("@") -> "邮箱格式错误"
    else -> "验证通过"
}

val description = when (status) {
    Status.LOADING -> {
        showProgress()
        "加载中..."  // 返回值
    }
    Status.SUCCESS -> {
        hideProgress()
        "加载成功"   // 返回值
    }
    Status.ERROR -> {
        hideProgress()
        showError()
        "加载失败"   // 返回值
    }
}

┌────────────────────────────────────────────────────────────────┐
│                    if vs when 选择指南                          │
├────────────────────────────────────────────────────────────────┤
│  场景                          │  推荐         │  原因          │
├───────────────────────────────┼──────────────┼───────────────┤
│  二元判断 (true/false)         │  if          │  简洁直观      │
│  多个离散值匹配                 │  when        │  替代 switch   │
│  类型检查 + 智能转换            │  when + is   │  自动 cast     │
│  范围检查                      │  when + in   │  语义清晰      │
│  复杂条件组合                   │  when 无参数  │  比 if-else 链 │
│                               │              │  更易读        │
└────────────────────────────────────────────────────────────────┘

val x = 5
val result = if (x > 3) {
    "big"
} else {
    "small"
}
println(result)

fun check(obj: Any) = when (obj) {
    is String -> obj.length
    is Int -> obj * 2
    else -> 0
}
 
println(check("Kotlin"))

enum class Direction { NORTH, SOUTH, EAST, WEST }
 
// ✅ 作为表达式：必须穷尽所有情况
val description = when (direction) {
    Direction.NORTH -> "向北"
    Direction.SOUTH -> "向南"
    Direction.EAST -> "向东"
    Direction.WEST -> "向西"
    // 无需 else，因为已覆盖所有枚举值
}
 
// ❌ 编译错误：缺少分支
val incomplete = when (direction) {
    Direction.NORTH -> "向北"
    Direction.SOUTH -> "向南"
    // Error: 'when' expression must be exhaustive, add necessary 'EAST', 'WEST' branches or 'else' branch
}

// 对于非枚举类型，必须有 else
fun describe(num: Int): String = when (num) {
    1 -> "一"
    2 -> "二"
    else -> "其他"  // 必须！Int 有无限可能值
}

// 定义密封类层次结构
sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val message: String, val code: Int) : Result()
    data object Loading : Result()
}
 
// 使用 when 处理所有情况
fun handleResult(result: Result): String = when (result) {
    is Result.Success -> "成功: ${result.data}"
    is Result.Error -> "错误 ${result.code}: ${result.message}"
    is Result.Loading -> "加载中..."
    // 无需 else！编译器知道只有这三种可能
}

// 假设后来新增了一个状态
sealed class Result {
    // ... 原有子类
    data object Cancelled : Result()  // 新增！
}
 
// 此时所有使用 when 的地方都会编译报错，提醒你处理新情况
// Error: 'when' expression must be exhaustive, add necessary 'Cancelled' branch

// 基础语法
for (item in collection) {
    println(item)
}
 
// 等价的 Java 增强 for 循环
// for (Item item : collection) { ... }

// 闭区间 [1, 5]：包含 1 和 5
for (i in 1..5) {
    print("$i ")  // 输出: 1 2 3 4 5
}
 
// 半开区间 [1, 5)：包含 1，不包含 5
for (i in 1 until 5) {
    print("$i ")  // 输出: 1 2 3 4
}
 
// 倒序迭代 (downTo)
for (i in 5 downTo 1) {
    print("$i ")  // 输出: 5 4 3 2 1
}
 
// 自定义步长 (step)
for (i in 0..10 step 2) {
    print("$i ")  // 输出: 0 2 4 6 8 10
}
 
// 组合使用
for (i in 10 downTo 0 step 3) {
    print("$i ")  // 输出: 10 7 4 1
}

┌─────────────────────────────────────────────────────────────┐
│                    范围操作符速查表                           │
├─────────────────────────────────────────────────────────────┤
│  语法              │  含义              │  示例结果           │
├──────────────────┼───────────────────┼───────────────────┤
│  1..5            │  闭区间 [1,5]       │  1, 2, 3, 4, 5    │
│  1 until 5       │  半开区间 [1,5)     │  1, 2, 3, 4       │
│  5 downTo 1      │  倒序闭区间         │  5, 4, 3, 2, 1    │
│  1..10 step 2    │  步长为 2           │  1, 3, 5, 7, 9    │
│  'a'..'z'        │  字符范围           │  a, b, c, ..., z  │
└─────────────────────────────────────────────────────────────┘

// 遍历 List
val fruits = listOf("Apple", "Banana", "Cherry")
for (fruit in fruits) {
    println(fruit)
}
 
// 遍历 Set
val uniqueNumbers = setOf(1, 2, 3, 2, 1)
for (num in uniqueNumbers) {
    print("$num ")  // 输出: 1 2 3
}
 
// 遍历 Map 的 entries
val scores = mapOf("Alice" to 95, "Bob" to 87)
for (entry in scores) {
    println("${entry.key}: ${entry.value}")
}
 
// 遍历字符串（String 也是 Iterable<Char>）
for (char in "Kotlin") {
    print("$char-")  // 输出: K-o-t-l-i-n-
}
 
// 遍历数组
val numbers = arrayOf(1, 2, 3)
for (n in numbers) {
    print("$n ")
}

// 解构 Map 的键值对
val userAges = mapOf("Alice" to 25, "Bob" to 30, "Charlie" to 35)
 
for ((name, age) in userAges) {
    println("$name is $age years old")
}
// 输出:
// Alice is 25 years old
// Bob is 30 years old
// Charlie is 35 years old
 
// 解构 Pair 列表
val coordinates = listOf(Pair(1, 2), Pair(3, 4), Pair(5, 6))
for ((x, y) in coordinates) {
    println("Point($x, $y)")
}
 
// 解构 data class
data class Person(val name: String, val age: Int)
val people = listOf(Person("Alice", 25), Person("Bob", 30))
 
for ((name, age) in people) {
    println("$name: $age")
}

// 上面的 for ((name, age) in userAges) 等价于：
for (entry in userAges) {
    val name = entry.component1()  // key
    val age = entry.component2()   // value
    println("$name is $age years old")
}

val colors = listOf("Red", "Green", "Blue")
 
// 使用 withIndex() 获取索引和元素
for ((index, color) in colors.withIndex()) {
    println("$index: $color")
}
// 输出:
// 0: Red
// 1: Green
// 2: Blue
 
// withIndex() 返回 IndexedValue<T> 对象的序列
// data class IndexedValue<out T>(val index: Int, val value: T)

val items = listOf("A", "B", "C")
 
// 方式 1: withIndex()（推荐）
for ((i, item) in items.withIndex()) {
    println("$i -> $item")
}
 
// 方式 2: indices 属性
for (i in items.indices) {
    println("$i -> ${items[i]}")
}
 
// 方式 3: forEachIndexed（函数式风格）
items.forEachIndexed { index, item ->
    println("$index -> $item")
}

// 自定义可迭代类
class CountDown(private val start: Int) {
    operator fun iterator(): Iterator<Int> = object : Iterator<Int> {
        private var current = start
        override fun hasNext() = current > 0
        override fun next() = current--
    }
}
 
// 使用自定义迭代
for (num in CountDown(5)) {
    print("$num ")  // 输出: 5 4 3 2 1
}

sealed class State {
    object Loading : State()
    data class Success(val data: String) : State()
    data class Error(val msg: String) : State()
}
 
fun handle(state: State) = when (state) {
    is State.Loading -> "加载中"
    is State.Success -> state.data
}

val list = listOf("A", "B", "C")
for ((index, value) in list.withIndex()) {
    if (index == 1) print(value)
}

// 基础语法
while (condition) {
    // 循环体 (loop body)
}
 
// 示例：计算阶乘
fun factorial(n: Int): Long {
    var result = 1L
    var counter = n
    while (counter > 0) {
        result *= counter
        counter--
    }
    return result
}
 
println(factorial(5))  // 输出: 120

┌─────────────────────────────────────────┐
│           while 循环执行流程              │
├─────────────────────────────────────────┤
│                                         │
│    ┌──────────────┐                     │
│    │  检查条件     │◄─────────┐         │
│    └──────┬───────┘          │         │
│           │                  │         │
│     ┌─────▼─────┐            │         │
│     │  true?    │            │         │
│     └─────┬─────┘            │         │
│       yes │  no              │         │
│     ┌─────▼─────┐    ┌───────┴───┐     │
│     │ 执行循环体 │    │  退出循环  │     │
│     └─────┬─────┘    └───────────┘     │
│           │                            │
│           └──────────────────┘         │
│                                         │
└─────────────────────────────────────────┘

// 基础语法
do {
    // 循环体 (至少执行一次)
} while (condition)
 
// 示例：用户输入验证
fun readPositiveNumber(): Int {
    var input: Int
    do {
        print("请输入正整数: ")
        input = readLine()?.toIntOrNull() ?: -1
    } while (input <= 0)
    return input
}
 
// 示例：至少执行一次的场景
var x = 10
do {
    println("x = $x")  // 即使条件一开始就是 false，也会执行一次
    x++
} while (x < 5)
// 输出: x = 10（执行了一次）

// 对比示例
var a = 0
while (a > 0) {
    println("while: $a")  // 不会执行
}
 
var b = 0
do {
    println("do-while: $b")  // 输出: do-while: 0
} while (b > 0)

// 场景 1: 读取数据直到结束标记
fun readUntilEnd(): List<String> {
    val lines = mutableListOf<String>()
    var line: String?
    while (readLine().also { line = it } != null && line != "END") {
        lines.add(line!!)
    }
    return lines
}
 
// 场景 2: 游戏主循环
fun gameLoop() {
    var isRunning = true
    while (isRunning) {
        processInput()
        updateGameState()
        render()
        isRunning = !isGameOver()
    }
}
 
// 场景 3: 重试机制
fun fetchWithRetry(maxRetries: Int): Result {
    var attempts = 0
    var result: Result
    do {
        result = tryFetch()
        attempts++
    } while (result.isFailure && attempts < maxRetries)
    return result
}

for (i in 1..10) {
    if (i == 5) break  // 当 i 等于 5 时退出循环
    print("$i ")
}
// 输出: 1 2 3 4

for (i in 1..10) {
    if (i % 2 == 0) continue  // 跳过偶数
    print("$i ")
}
// 输出: 1 3 5 7 9

fun findFirst(list: List<Int>, target: Int): Int? {
    for (item in list) {
        if (item == target) return item  // 找到后立即返回
    }
    return null
}

// 标签语法: identifier@ 
outer@ for (i in 1..5) {
    inner@ for (j in 1..5) {
        // 可以使用 break@outer 或 continue@outer
    }
}

// 不使用标签：只能退出内层循环
for (i in 1..3) {
    for (j in 1..3) {
        if (j == 2) break  // 只退出内层 j 循环
        println("i=$i, j=$j")
    }
}
// 输出:
// i=1, j=1
// i=2, j=1
// i=3, j=1
 
// 使用标签：可以退出外层循环
outer@ for (i in 1..3) {
    for (j in 1..3) {
        if (i == 2 && j == 2) break@outer  // 退出外层 i 循环
        println("i=$i, j=$j")
    }
}
// 输出:
// i=1, j=1
// i=1, j=2
// i=1, j=3
// i=2, j=1

outer@ for (i in 1..3) {
    for (j in 1..3) {
        if (j == 2) continue@outer  // 跳过外层循环的当前迭代
        println("i=$i, j=$j")
    }
}
// 输出:
// i=1, j=1
// i=2, j=1
// i=3, j=1
// 注意：每次 j=2 时，直接跳到下一个 i，j=3 永远不会执行

fun processNumbers(numbers: List<Int>) {
    numbers.forEach { num ->
        if (num == 0) return  // 从 processNumbers 函数返回！
        println(num)
    }
    println("处理完成")  // 如果遇到 0，这行不会执行
}
 
processNumbers(listOf(1, 2, 0, 3))
// 输出:
// 1
// 2
// （函数直接返回，"处理完成"不会打印）

fun processNumbers(numbers: List<Int>) {
    numbers.forEach label@{ num ->
        if (num == 0) return@label  // 仅从 Lambda 返回，继续下一次迭代
        println(num)
    }
    println("处理完成")
}
 
processNumbers(listOf(1, 2, 0, 3))
// 输出:
// 1
// 2
// 3
// 处理完成

fun processNumbers(numbers: List<Int>) {
    numbers.forEach { num ->
        if (num == 0) return@forEach  // 使用隐式标签
        println(num)
    }
    println("处理完成")
}

fun demo(list: List<Int>) {
    // 形式 1: 显式标签
    list.forEach myLabel@{
        if (it < 0) return@myLabel
        println(it)
    }
    
    // 形式 2: 隐式标签（函数名）
    list.forEach {
        if (it < 0) return@forEach
        println(it)
    }
    
    // 形式 3: 匿名函数（无需标签）
    list.forEach(fun(value) {
        if (value < 0) return  // 从匿名函数返回
        println(value)
    })
}

val result = run outer@{
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return@outer "找到了 3"
    }
    "没找到"
}
println(result)  // 输出: 找到了 3

┌──────────────────────────────────────────────────────────────┐
│                    跳转语句速查表                               │
├──────────────────────────────────────────────────────────────┤
│  语句             │  作用范围          │  行为                  │
├──────────────────┼───────────────────┼───────────────────────┤
│  break           │  最近闭合循环       │  终止循环              │
│  break@label     │  指定标签的循环     │  终止指定循环           │
│  continue        │  最近闭合循环       │  跳到下一次迭代         │
│  continue@label  │  指定标签的循环     │  跳到指定循环的下一迭代   │
│  return          │  最近闭合函数       │  从函数返回             │
│  return@label    │  指定标签的 Lambda  │  从 Lambda 返回        │
└───────────────────────────────────────────────────────────────┘

var count = 0
do {
    count++
} while (count > 10)
println(count)

fun test() {
    listOf(1, 2, 3).forEach {
        if (it == 2) return
        print(it)
    }
    print("done")
}
test()

┌─────────────────────────────────────────────────────────────┐
│              穷尽性检查 (Exhaustive Check)                    │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   when 作为表达式 + enum/sealed class                         │
│           ↓                                                 │
│   编译器自动检查是否覆盖所有分支                                 │
│           ↓                                                 │
│   ┌─────────────┐    ┌─────────────┐                        │
│   │ 全部覆盖 ✓   │    │ 有遗漏 ✗    │                         │
│   │ 无需 else   │    │ 编译报错    │                          │
│   └─────────────┘    └─────────────┘                        │
│                                                             │
│   优势：新增子类时，所有未处理的 when 都会报错提醒                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘

// 1. 优先使用 when 替代多层 if-else
val grade = when (score) {
    in 90..100 -> "A"
    in 80..89 -> "B"
    in 70..79 -> "C"
    else -> "D"
}
 
// 2. 使用密封类配合 when，获得编译期安全
sealed class UiState { ... }
fun render(state: UiState) = when (state) {
    is UiState.Loading -> showLoading()
    is UiState.Success -> showData(state.data)
    is UiState.Error -> showError(state.message)
    // 编译器确保不会遗漏
}
 
// 3. 使用 withIndex() 而非手动维护索引
for ((index, item) in list.withIndex()) {
    println("$index: $item")
}
 
// 4. Lambda 中使用 return@label 而非裸 return
list.forEach {
    if (it < 0) return@forEach  // 明确意图
    process(it)
}

// 1. 避免过深的嵌套 if
// Bad
if (a) {
    if (b) {
        if (c) { ... }
    }
}
// Good: 使用 when 或提前 return
 
// 2. 避免在 when 表达式中滥用 else
// Bad: else 会"吞掉"未来新增的枚举值
when (status) {
    Status.A -> ...
    else -> ...  // 危险！
}
// Good: 显式列出所有分支
 
// 3. 避免在 Lambda 中使用裸 return（除非确实要退出外层函数）
list.forEach {
    if (condition) return  // 可能不是你想要的行为
}

// ❌ 编译错误
val result = if (flag) "yes"  // 缺少 else
 
// ✅ 正确
val result = if (flag) "yes" else "no"

fun process(list: List<Int>) {
    list.forEach {
        if (it == 0) return  // 从 process 函数返回！
        println(it)
    }
    println("done")  // 可能不会执行
}

var x = 100
do {
    println(x)  // 即使条件为 false，也会执行一次
} while (x < 10)
// 输出: 100

fun check(x: Int) = when {
    x < 0 -> "negative"
    x == 0 -> "zero"
    x in 1..10 -> "small"
    else -> "large"
}
println(check(5))

outer@ for (i in 1..3) {
    for (j in 1..3) {
        if (i * j > 4) break@outer
        print("$i$j ")
    }
}