流程控制語句是程式語言中的核心之一。可以分為 分支語句、迴圈語句和跳轉語句。下面我們深入的瞭解Kotlin的流程控制語句。

if

if-else語句是控制程式流程的最基本的形式，其中else是可選的。

在Kotlin中，if是表示式，比如它可以返回一個值。 是除了condition ? then : else)之外的唯一一個三元表達。

傳統用法

val a = 10
val b = 20
var max_0: Int = a

if (a > b) {
    max_0 = a

} else {
    max_0 = b
}

println("----------------------------------")
println("max_0:$max_0")
println("----------------------------------")

// Log
--------------
max_0:20
--------------
 

作為表示式

var max_1 = if (a > b) a else b
println("--------------")
println("max_1:$max_1")
println("--------------")

//Log
--------------
max_1:20
--------------

作為程式碼塊

println("--------------")
val max_2 = if (a > b) {
    println("Choose a")
    a
} else {
    println("Choose b")
    b
}

println("max_2:$max_2")
println("--------------")

// Log  
--------------
Choose b
max_2:20
--------------
 

if作為程式碼塊時，最後一行必須為該塊的返回值.

如果 if 表示式只有一個分支， 或者分支的結果是 Unit , 它的值就是 Unit 。

if-else語句規則：

• if後的括號不能省略，括號裡表示式的值最終必須返回的是布林值
• 如果條件體內只有一條語句需要執行，那麼if後面的大括號可以省略，但這是一種極為不好的程式設計習慣。
• 對於給定的if，else語句是可選的，else if 語句也是可選的
• else和else if同時出現時，else必須出現在else if 之後
• 如果有多條else if語句同時出現，那麼如果有一條else if語句的表示式測試成功，那麼會忽略掉其他所有else if和else分支。
• 如果出現多個if,只有一個else的情形，else子句歸屬於最內層的if語句

when

when取代了C風格語言的switch。相較switch而言，when語句顯得更加的強大，靈活性更好。

when會對所有的分支進行檢查直到有一個條件滿足。 when 可以用做表示式或宣告。如果用作表示式的話，那麼滿足條件的分支就是總表示式。如果用做宣告，不滿足條件的分支的的的值會被忽略，只保留滿足條件的分支，而且返回的值也是最後一個表示式的值。

傳統用法

val x : Int = 10

when (x) {
    9 -> println("x:${x + 10}")
    10 -> println("x:$x")
    else -> print("x:$x")
}

分支條件一致

如果有分支可以用同樣的方式處理的話， 分支條件可以連在一起處理。

when (x) {
    0,1 -> print("x == 0 or x == 1")
    else -> print("otherwise")
}

使用任意表達式作為分支的條件

when (x) {
    parseInt(s) -> print("s encode x")
    else -> print("s does not encode x")
}

when (x) {
    in 1..10 -> print("x is in the range")
    in validNumbers -> print("x is valid")
    !in 10..20 -> print("x is outside the range")
    else -> print("none of the above")
}

作為表示式

val hasPrefix = when (x) {
    is String -> x.startsWith("prefix")
    else -> false
}

for

for 迴圈通過任何提供的迭代器進行迭代。 語法如下：

for (item in collection)
    print(item)

如果遍歷list或者array可以通過索引進行迭代：

for (i in array.indices)
    print(array[i])

while迴圈

while語句

while語句在迴圈剛開始時，會計算一次布林表示式的值，如果滿足條件，進入迴圈，如果不滿足條件，將跳出迴圈。而在while語句的下一次迭代開始前會計算再一次布林值，如此重複。

while (x > 0) {
    x--
} 

dowhile語句

dowhile語句與while語句類是，唯一的區別是doWhile語句會至少執行一次，即便布林表示式的第一次計算就是false.而while語句中，如果 布林表示式的第一次計算的值是false，該迴圈不會執行。

do {
    val y = retrieveData()
} while (y != null) // y 在這是可見的

返回與跳轉

Kotlin中有return、break、continue等三種返回跳轉操作符。

• return

  1. 指定一個方法返回什麼值

  2. 導致當前方法結束，並返回返回指定的值

     fun main(args: Array<String>) {
     
     
         println("testA:${testA(10)}")
     
         println("----------")
     
         println("testB:${testB(10)}")
     }
     
     fun testA(a : Int):Int{
         if (a > 0) {
             return -1
         } else {
             return 1
         }
     }
     
     fun testB(a : Int):Int{
     
         println("a:$a")
     
         if (a > 0) {
             return -1
         } else {
             return 1
         }
     
         a++
     
         print("a:$a")
     }
     
     // Log列印
     testA:-1
     ----------
     a:10
     testB:-1
     

• break
  結束最近的閉合迴圈，不執行迴圈中剩餘的語句

  val arraysA = listOf("A", "B", "C", "D")
  val arraysB  = listOf(1,2,3,4)
  for (itemA in arraysA) {
      for (itemB in arraysB) {
          if (itemB > 2) {
              break
          }
          println("itemB:$itemB")
      }
  
      if (itemA == "C") {
          break
      }
      println("itemA:$itemA")
  }
  
  // Log
  itemB:1
  itemB:2
  itemA:A
  itemB:1
  itemB:2
  itemA:B
  itemB:1
  itemB:2
  

從Log列印可以看出，第一個break結束的是for (itemB in arraysB)這個迴圈，而第二個break結束的是for (itemA in arraysA)，它們的共通點就是結束都是距離它們最近的一個迴圈。

• continue
  跳到最近的閉合迴圈的下一次迴圈

  val arraysA = listOf("A", "B", "C", "D")
  val arraysB  = listOf(1,2,3,4)
  
  for (itemA in arraysA) {
      var i : Int = 0
      for (itemB in arraysB) {
          i++
          if (itemB > 2) {
              continue
          }
  
          println("itemB:$itemB")
      }
  
      if (itemA == "C") {
          continue
      }
      println("i:$i")
      println("itemA:$itemA")
      println("---------")
  }
  
  // Log
  itemB:1
  itemB:2
  i:4
  itemA:A
  ---------
  itemB:1
  itemB:2
  i:4
  itemA:B
  ---------
  itemB:1
  itemB:2
  itemB:1
  itemB:2
  i:4
  itemA:D
  ---------   
  

  從上述Log上，可以清楚看到，兩個迴圈分別迴圈了四次，但是在碰到continue時，會跳出當前迴圈並執行下一次迴圈。

標籤

在 Kotlin 中表達式可以新增標籤，標籤通過@結尾來表示，比如：[email protected]，[email protected]

[email protected] for (i in 1..100){
    //...
}

break和標籤

[email protected] for (itemA in arraysA) {
    var i : Int = 0
    for (itemB in arraysB) {
        i++
        if (itemB > 2) {
            [email protected]
        }

        println("itemB:$itemB")
    }

    println("i:$i")
    println("itemA:$itemA")
    println("---------")
}

// Log列印
itemB:1
itemB:2

從Log列印，第一個迴圈執行了一次，第二個迴圈執行了兩次，便跳出了封閉的迴圈。意味著break跳到標籤後邊的表示式，並不再執行此表示式直接跳過，執行後邊的語句。

continue和標籤

[email protected] for (itemA in arraysA) {
    var i : Int = 0
    for (itemB in arraysB) {
        i++
        if (itemB > 2) {
            [email protected]
        }

        println("itemB:$itemB")
    }

    println("i:$i")
    println("itemA:$itemA")
    println("---------")
}

// Log列印
itemB:1
itemB:2
itemB:1
itemB:2
itemB:1
itemB:2
itemB:1
itemB:2

之前說過，continue是跳到最近的閉合迴圈的下一次迴圈，但是加上標籤以後，直接跳轉到了第一個迴圈，也就是for (itemA in arraysA)，並沒有執行最近的閉合迴圈的下一次迴圈。意味著continue直接跳轉到標籤後面的語句並執行。

return和標籤

val ints = listOf(0, 1, 2, 3)

fun main(args: Array<String>) {

    foo()

}

fun foo() {
    ints.forEach {
        if (it ==0) [email protected]
        println(it)
    }
}

// Log列印
1
2
3

fun foo() {
    ints.forEach {
    if (it ==0) [email protected]
        print(it)
    }
}

從Log列印可以看出，return會跳轉到標籤後邊的表示式處，並執行該表示式。

命名函式自動定義標籤

foo outer() {
    foo inner() {
        [email protected]
    }
}

作用域

從作用域來看，標籤和變數是一致的，都有相對應的作用於。在main方法裡面定義了一個標籤[email protected],在foo方法裡面呼叫時，提示“Unresolved reference:@list”，意味著list標籤的作用域應該在main方法裡，在foo方法裡並不能夠呼叫。