本文收录于 kotlin入门潜修专题系列，欢迎学习交流。

创作不易，如有转载，还请备注。

控制表达式

kotlin中控制表达式主要有四个：if、when、for、while 。本篇文章将探讨这四种表达式如何使用以及使用场景是什么。

if 表达式

在kotlin中，if不仅可以作为条件判断语句，而且还可以作为一个表达式，当作为表达式出现的时候是有返回值的。因此kotlin不再提供三元表达式（即condition? then:else），if-else已经足够表达上述情景。

if表达式使用示例如下：

            var min = 0
            var a = -1
            if (a < min) min = a//if 条件判断

            var b = -2
            if (a < b) {//if else一起使用
                min = a
            } else {
                min = b
            }

            min = if (a < b) a else b//作为表达式使用
            println(min)//打印 '-2'

kotlin中if表达式可以是一个块，块的最后一个表达式作为返回值，如下所示：

            var min = 0
            val a = -1
            val b = -2
            min = if (a < b) {//if块，注意这里需要提供返回值并赋值于min变量
                println("a < b")//可以执行语句
                a//最后一个表达式作为返回值
            } else {//同if
                println("a > b")
                b
            }
            println(min)

注意，当if作为表达式的时候，必须要跟else分支。

When表达式

对于类c语言，大家都很熟悉switch表达式，然而在kotlin中不再有这个表达式，取而代之的是就是when表达式。

            val a = -1
            when (a) {
                1 -> println("a == 1")//注意，这即表示一个匹配条件，类似于switch中的case
                -1 -> println("a == -1")
                0 -> println("a == 0")
                else -> {//类似于switch中的default
                    print("a not match...")
                }
            }

when表达式会依次检测每个条件语句，直到匹配了某个条件即终止检测。如果所有条件都不匹配则进入else分支。
此外，当when单纯作为语句出现时，else分支是可以省略的，但是当作为表达式出现时则必须要有else分支，除非编译器能够确认when中的分支能够cover所有的场景，比如when表达式处理的是枚举类或者sealed类。具体示例如下：

            val a = -1
            val b = when (a) {//when作为表达式存在，需要返回值，并赋值于b
                1 -> println("a == 1")
                -1 -> println("a == -1")
                0 -> println("a == 0")
                else -> {//注意，这个else此时必须存在，否则编译器会报错
                    print("a not match...")
                }
            }

对于条件不同，而处理结果相同的情形，when可以用"，"进行条件分割,如下所示

            val a = -1
            when (a) {
                0, 1 -> println("a != 0 且 a != 0")//用逗号,合并不同case
                -1 -> println("a == -1")
            }

kotlin中的when非常强大，它可以支持任意表达式（而不局限于常量）作为判断条件，如下所示：

            val a = -1
            val b = 2
            when (a) {
                in -2..10 -> println("a在-2-10区间内")//支持任意表达式
                b.toInt() -> println("a == b == 2")
            }

when的另一个用途可以用作类型检测，如下所示：

           fun isInt(a:Any) = when (a) {
                is Int -> println("a是个整数")//这里利用is关键字进行类型判断
                else -> println("a不是个整数")
            }
            isInt(2)//打印 'a是个整数'

when同时可以作为if-else 的替代方案，如下所示：

            val x = 1
            when {//when块执行后，会打印'x>0'
                x > 0 -> print("x > 0")
                x < 0 -> print("x < 0")
                else -> print("x == 0")
            }

上面这种替代方案，并没有指定条件（即when没有接收入参），此时会默认根据每个语句的true和false来进行匹配，如果某个语句返回了true则终止检测。

For循环

kotlin中的for循环可以遍历一切提供有迭代器的对象集合，其使用语法如下：

            val ints: Array<Int> = arrayOf(1, 2, 3)
            for (item in ints) {
                println(item)//打印'1 2 3'
            }

for循环同时可以迭代一段指定范围的数字，如下所示：

            for (item in 1..3) {//range for循环
                println(item)//打印' 1 2 3'
            }

            for (item in 10 downTo 0 step 2){
                println(item)//'打印 10 8 6 4 2 0'
            }

由上述代码可知，kotlin的for循环十分强大，支持的操作符即丰富有语义化。比如downTo（即递减到某个值）、step（步长，每次迭代的步长值）等。
对于遍历数组或者一段范围的数字，for循环并不会生成迭代对象，而是会被编译器编译为基于索引的for循环。如果数组或者集合想直接通过索引进行遍历，也可以通过以下方法进行：

            val ints: Array<Int> = arrayOf(1, 2, 3)
            for (index in ints.indices){//第一种方法，首先获取索引，然后根据索引取值
                println(ints[index])
            }
            for ((index, value) in ints.withIndex()){//第二种方法，直接可以获取索引以及其对应的值
                println("the element at $index is $value")
            }

While循环

kotlin中的while循环和java基本一致，示例如下：

            var k = 10
            while (k > 0){//while循环
                k--
            }

            do {//do-while循环
                k++
            }while (k < 10)

while循环和其他语言相差不大，也比较简单，这里不再阐述。