Kotlin 条件语句

1. 开始之前

条件语句是编程最重要的基础之一。条件语句是编程语言中处理决策的命令。借助条件语句，代码是动态的，这意味着它可以根据不同的条件表现出不同的行为。

本 Codelab 教您如何使用if/else和when语句和表达式在 Kotlin 中编写条件语句。

先决条件

  • Kotlin 编程基础知识，包括变量以及println()和main()函数

您将学习

  • 如何编写布尔表达式。
  • 如何编写if/else语句。
  • 如何编写when语句。
  • 如何编写if/else表达式。
  • 如何编写when表达式。
  • 如何在when条件语句中使用逗号来定义多个分支的公共行为。
  • 如何在when条件语句中使用in范围来定义一系列分支的公共行为。
  • 如何使用is关键字编写when条件语句。

您将需要

  • 可以访问 Kotlin Playground 的 Web 浏览器

2. 使用 if/else 语句表达条件

生活中，根据面临的情况采取不同的行动是很常见的。例如，如果天气寒冷，你会穿外套；如果天气温暖，你就不穿外套。

A flowchart that describes a decision that's made when the weather is cold. A yes arrow points to

决策也是编程中的一个基本概念。您编写有关程序在给定情况下应如何运行的指令，以便它在发生这种情况时可以相应地采取行动或做出反应。在 Kotlin 中，当您希望程序根据条件执行不同的操作时，可以使用if/else语句。在下一节中，您将编写一个if语句。

使用布尔表达式编写if条件

假设您正在构建一个程序，告诉驾驶员在遇到交通信号灯时应该做什么。重点关注第一个条件：红灯。在红灯处你会做什么？停车！

A flowchart that describes a decision made when the traffic-light color is red. A yes arrow points to a

在 Kotlin 中，您可以使用if语句来表达此条件。让我们看一下if语句的结构

A diagram that describes an if statement with the if keyword followed by a pair of parentheses with a condition inside them. After that, there's a pair of curly braces with a body in them. The condition block is highlighted.

要使用if语句，需要使用if关键字，后跟要评估的条件。您需要使用布尔表达式来表达条件。表达式组合返回值的值、变量和运算符。布尔表达式返回布尔值。

之前，您学习了赋值运算符，例如：

val number = 1

=赋值运算符将number变量赋值为1。

相反，布尔表达式是用比较运算符构建的，它比较等式两侧的值或变量。让我们来看一个比较运算符。

1 == 1

==比较运算符将值彼此进行比较。您认为此表达式返回什么布尔值？

查找此表达式的布尔值

  1. 使用Kotlin Playground运行您的代码。
  2. 在函数体中，添加一个println()函数，然后将1 == 1表达式作为参数传递给它。
fun main() {
    println(1 == 1)
}
  1. 运行程序，然后查看输出。
true

第一个1值等于第二个1值，因此布尔表达式返回true值，这是一个布尔值。

试试看

除了==比较运算符之外，您还可以使用其他比较运算符来创建布尔表达式。

  • 小于：<
  • 大于：>
  • 小于或等于：<=
  • 大于或等于：>=
  • 不等于：!=

练习使用简单的表达式的比较运算符。

  1. 在参数中，将==比较运算符替换为<比较运算符。
fun main() {
    println(1 < 1)
}
  1. 运行程序，然后查看输出。

输出返回false值，因为第一个1值不小于第二个1值。

false
  1. 使用其他比较运算符和数字重复前两步。

编写一个简单的if语句

既然您已经看到了一些如何编写布尔表达式的示例，您可以编写您的第一个if语句。if语句的语法如下：

A diagram that describes an if statement with the if keyword followed by a pair of parentheses with a condition inside them. After that, there's a pair of curly braces with a body inside them. The body block is highlighted.

if语句以if关键字开头，后跟一个条件（即括号内的布尔表达式）和一对大括号。主体是在条件之后的一对大括号内的一系列语句或表达式。只有满足条件时，这些语句或表达式才会执行。换句话说，只有当if分支中的布尔表达式返回值为true时，大括号内的语句才会执行。

为红灯条件编写一个if语句。

  1. 在main()函数内，创建一个trafficLightColor变量并为其赋值"Red"。
fun main() {
    val trafficLightColor = "Red"
}
  1. 为红灯条件添加一个if语句，然后传递trafficLightColor == "Red"表达式。
fun main() {
    val trafficLightColor = "Red"

    if (trafficLightColor == "Red") {
        
    } 
}
  1. 在if语句的主体中，添加一个println()函数，然后传递"Stop"参数。
fun main() {
    val trafficLightColor = "Red"

    if (trafficLightColor == "Red") {
        println("Stop")
    } 
}
  1. 运行程序，然后查看输出。
Stop

trafficLightColor == "Red"表达式返回true值，因此执行println("Stop")语句，这将打印Stop消息。

A diagram that highlights the if statement of trafficLightColor ==

添加一个else分支

现在您可以扩展程序，以便在交通灯不是红色时告诉驾驶员通行。

A flowchart that describes a decision made when the traffic-light color is red. A yes arrow points to a

您需要添加一个else分支来创建一个if/else语句。分支是代码的不完整部分，您可以将其组合起来形成语句或表达式。else分支必须跟在if分支之后。

A diagram that describes an if/else statement with the if keyword followed by parentheses with a condition inside them. After that, there's a pair of curly braces with body 1 inside them followed by an else keyword followed by parentheses. After that, there's a pair of curly braces with a body 2 block inside them.

在if语句的右大括号之后，添加else关键字，后跟一对大括号。在else语句的大括号内，您可以添加第二个主体，该主体仅在if分支中的条件为假时执行。

在您的程序中添加一个else分支。

  1. 在if语句的右大括号之后，添加else关键字，后跟另一对大括号。
fun main() {
    val trafficLightColor = "Red"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else {

    }
}
  1. 在else关键字的大括号内，添加一个println()函数，然后传递"Go"参数。
fun main() {
    val trafficLightColor = "Red"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else {
        println("Go")
    }
}
  1. 运行此程序，然后查看输出。
Stop

该程序的行为与添加else分支之前的行为相同，但它不会打印Go消息。

  1. 将trafficLightColor变量重新赋值为"Green"值，因为您希望驾驶员在绿灯时通行。
fun main() {
    val trafficLightColor = "Green"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else {
        println("Go")
    }
}
  1. 运行此程序，然后查看输出。
Go

如您所见，现在程序打印Go消息而不是Stop消息。

A diagram that highlights the if/else statement with the trafficLightColor ==

您将trafficLightColor变量重新赋值为"Green"值，因此if分支中计算的trafficLightColor == "Red"表达式返回false值，因为"Green"值不等于"Red"值。

结果，程序跳过if分支中的所有语句，而是执行else分支中的所有语句。这意味着执行println("Go")函数，但不执行println("Stop")函数。

添加else if分支

通常，交通信号灯还有一个黄色，告诉驾驶员缓慢通行。您可以扩展程序的决策过程以反映这一点。

A flowchart that describes a decision made when the traffic-light color is red. A yes arrow points to a

您学习了如何编写满足单个决策点的条件语句，使用包含单个if和单个else分支的if/else语句。如何处理具有多个决策点的更复杂的多分支情况？当您面临多个决策点时，需要创建具有多层条件的条件语句，当您向if/else语句添加else if分支时，就可以做到这一点。

在if分支的右大括号之后，需要添加else if关键字。在else if关键字的括号内，需要添加一个布尔表达式作为else if分支的条件，后跟一对大括号内的主体。只有在条件 1 失败但条件 2 满足时，才会执行主体。

A diagram that describes an if/else statement with the if keyword followed by parentheses with a condition 1 block inside them. After that, there's a pair of curly braces with a body 1 inside them. That's followed by an else if keyword with parentheses with a condition 2 block in them. It's then followed with a pair of curly braces with a body 2 block inside them. That's then followed by an else keyword with another pair of curly braces with a body 3 block inside them.

else if分支始终位于if分支之后，但在else分支之前。您可以在一个语句中使用多个else if分支。

A diagram that shows an if/else condition with multiple else if branches between the if and else branches. A text annotated around the else if branches state that there's multiple else if branches.

if语句也可以包含if分支和else if分支，而没有任何else分支。

A diagram that describes an if/else statement with the if keyword followed by parentheses with a condition 1 block inside them. After that, there's a pair of curly braces with a body 1 inside them. That's followed by an else if keyword with parentheses and a condition 2 block inside them. It's then followed with a pair of curly braces with a body 2 block inside them.

在您的程序中添加一个else if分支。

  1. 在if语句的右大括号之后，添加else if (trafficLightColor == "Yellow")表达式，后跟大括号。
fun main() {
    val trafficLightColor = "Green"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else if (trafficLightColor == "Yellow") {

    } else {
        println("Go")
    }
}
  1. 在else if分支的大括号内，添加一个println()语句，然后传递"Slow"字符串参数。
fun main() {
    val trafficLightColor = "Green"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else if (trafficLightColor == "Yellow") {
        println("Slow")
    } else {
        println("Go")
    }
}
  1. 将trafficLightColor变量重新赋值为"Yellow"字符串值。
fun main() {
    val trafficLightColor = "Yellow"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else if (trafficLightColor == "Yellow") {
        println("Slow")
    } else {
        println("Go")
    }
}
  1. 运行此程序，然后查看输出。
Slow

现在程序打印Slow消息，而不是Stop或Go消息。

A diagram that highlights the if/else statement with the trafficLightColor ==

为什么程序只打印了Slow消息，而没有打印其他行

  • 变量trafficLightColor被赋值为"Yellow"。
  • 值"Yellow"不等于"Red"，所以if分支（图中标记为1）的布尔表达式返回false。程序跳过if分支内的所有语句，不会打印Stop消息。
  • 由于if分支的结果为false，程序继续评估else if分支内的布尔表达式。
  • 值"Yellow"等于"Yellow"，所以else if分支（图中标记为2）的布尔表达式返回true。程序执行else if分支内的所有语句，并打印Slow消息。
  • 由于else if分支的布尔表达式返回true，程序跳过其余的分支。因此，else分支中的所有语句都不会执行，程序不会打印Go消息。

试试看

你注意到当前程序中存在一个bug了吗？

在第一单元，你学习了一种名为编译错误的bug类型，由于代码中的语法错误，Kotlin无法编译代码，程序无法运行。在这里，你面临另一种类型的bug，称为逻辑错误，程序可以运行，但不会产生预期的输出。

假设你只希望驾驶员在交通灯为绿色时才驾驶。如果交通灯坏了或关闭了怎么办？你希望驾驶员驾驶还是收到错误警告？

不幸的是，在当前程序中，如果交通灯颜色不是红色或黄色，驾驶员仍然会被建议通行。

修复这个问题

  1. 将trafficLightColor变量重新赋值为"Black"，以模拟关闭的交通灯。
fun main() {
    val trafficLightColor = "Black"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else if (trafficLightColor == "Yellow") {
        println("Slow")
    } else {
        println("Go")
    }
}
  1. 运行此程序，然后查看输出。
Go

请注意，即使trafficLightColor变量没有赋值为"Green"，程序也会打印Go消息。你能修复此程序使其反映正确的行为吗？

A flowchart that describes a decision made when the traffic-light color is red. A yes arrow points to a

你需要修改程序，使其打印：

  • 只有当trafficLightColor变量赋值为"Green"时，才打印Go消息。
  • 当trafficLightColor变量未赋值为"Red"、"Yellow"或"Green"时，打印Invalid traffic-light color消息。

修复else分支

else分支始终位于if/else语句的末尾，因为它是一个兜底分支。当前面分支的所有其他条件都不满足时，它会自动执行。因此，当你想只在满足特定条件时执行操作时，else分支不适用。在交通灯的情况下，你可以使用else if分支来指定绿色交通灯的条件。

使用else if分支来评估绿色交通灯条件

  1. 在当前的else if分支之后，添加另一个else if (trafficLightColor == "Green")分支。
fun main() {
    val trafficLightColor = "Black"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else if (trafficLightColor == "Yellow") {
        println("Slow")
    } else if (trafficLightColor == "Green") {
        println("Go")
    }
}
  1. 运行此程序，然后查看输出。

输出为空，因为你没有一个else分支在前面条件不满足时执行。

  1. 在最后一个else if分支之后，添加一个else分支，并在其中包含println("Invalid traffic-light color")语句。
fun main() {
    val trafficLightColor = "Black"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else if (trafficLightColor == "Yellow") {
        println("Slow")
    } else if (trafficLightColor == "Green") {
        println("Go")
    } else {
        println("Invalid traffic-light color")
    }

}
  1. 运行此程序，然后查看输出。
Invalid traffic-light color
  1. 将trafficLightColor变量赋值为除"Red"、"Yellow"或"Green"之外的另一个值，然后重新运行程序。

程序的输出是什么？

良好的编程实践是在输入验证中明确使用else if分支来处理绿色，并使用else分支来捕获其他无效输入。这确保了只有当交通灯为绿色时，驾驶员才会被指示通行。对于其他情况，会有一个明确的消息表明交通灯的行为不符合预期。

3. 使用when语句处理多个分支

你的trafficLightColor程序看起来包含多个条件，也称为分支，比较复杂。你可能想知道是否可以简化一个包含更多分支的程序。

在Kotlin中，当处理多个分支时，可以使用when语句代替if/else语句，因为它提高了可读性，指的是人类读者（通常是开发人员）阅读代码的难易程度。在编写代码时考虑可读性非常重要，因为其他开发人员很可能需要在代码的整个生命周期中审查和修改你的代码。良好的可读性确保开发人员能够正确理解你的代码，并且不会无意中引入bug。

when语句在需要考虑两个以上分支时是首选。

A diagram that shows the anatomy of a when statement. It starts with a when keyword followed by a pair of curly braces with a parameter block inside them. Next, inside a pair curly braces, there are three lines of cases. Inside each line, there's a condition block followed by an arrow symbol and a body block. It's noted that each of the lines of cases are evaluated sequentially.

when语句通过参数接受单个值。然后依次将该值与每个条件进行评估。然后执行满足的第一个条件的相应主体。每个条件和主体由箭头（->）分隔。与if/else语句类似，每一对条件和主体在when语句中都称为分支。与if/else语句类似，你可以在when语句中添加else分支作为你的最终条件，它充当兜底分支。

用when语句改写if/else语句

在交通灯程序中，已经存在多个分支：

  • 红色交通灯颜色
  • 黄色交通灯颜色
  • 绿色交通灯颜色
  • 其他交通灯颜色

转换程序以使用when语句

  1. 在main()函数中，删除if/else语句。
fun main() {
    val trafficLightColor = "Black"

}
  1. 添加一个when语句，然后将trafficLightColor变量作为参数传递给它。
fun main() {
    val trafficLightColor = "Black"

    when (trafficLightColor) {
    }
}
  1. 在when语句的主体中，添加"Red"条件，后跟箭头和println("Stop")主体。
fun main() {
    val trafficLightColor = "Black"

    when (trafficLightColor) {
        "Red" -> println("Stop")
    }
}
  1. 在下一行，添加"Yellow"条件，后跟箭头和println("Slow")主体。
fun main() {
    val trafficLightColor = "Black"

    when (trafficLightColor) {
        "Red" -> println("Stop")
        "Yellow" -> println("Slow")
    }
}
  1. 在下一行，添加"Green"条件，后跟箭头和println("Go")主体。
fun main() {
    val trafficLightColor = "Black"

    when (trafficLightColor) {
        "Red" -> println("Stop")
        "Yellow" -> println("Slow")
        "Green" -> println("Go")
    }
}
  1. 在下一行，添加else关键字，后跟箭头和println("Invalid traffic-light color")主体。
fun main() {
    val trafficLightColor = "Black"

    when (trafficLightColor) {
        "Red" -> println("Stop")
        "Yellow" -> println("Slow")
        "Green" -> println("Go")
        else -> println("Invalid traffic-light color")
    }
}
  1. 将trafficLightColor变量重新赋值为"Yellow"。
fun main() {
    val trafficLightColor = "Yellow"

    when (trafficLightColor) {
        "Red" -> println("Stop")
        "Yellow" -> println("Slow")
        "Green" -> println("Go")
        else -> println("Invalid traffic-light color")
    }
}

运行此程序后，你认为输出是什么？

  1. 运行程序，然后查看输出。
Slow

7112edfc7c7b7918.png

输出是Slow消息，因为：

  • 变量trafficLightColor被赋值为"Yellow"。
  • 程序按顺序逐一评估每个条件。
  • 值"Yellow"不等于"Red"，所以程序跳过第一个主体。
  • 值"Yellow"等于"Yellow"，所以程序执行第二个主体并打印Slow消息。
  • 执行了一个主体，所以程序忽略第三和第四个分支，并离开when语句。

在when语句中编写更复杂的条件

到目前为止，你学习了如何为单个相等条件编写when条件，例如当trafficLightColor变量赋值为"Yellow"时。接下来，你将学习使用逗号（,）、in关键字和is关键字来构成更复杂的when条件。

构建一个程序来确定1到10之间的数字是否是质数。

  1. 在新窗口中打开Kotlin playground。

稍后你将回到交通灯程序。

  1. 定义一个x变量，然后将其赋值为3。
fun main() {
    val x = 3
}
  1. 添加一个when语句，其中包含2、3、5和7条件的多个分支，并在每个分支后跟一个println("x is prime number between 1 and 10.")主体。
fun main() {
    val x = 3

    when (x) {
        2 -> println("x is a prime number between 1 and 10.")
        3 -> println("x is a prime number between 1 and 10.")
        5 -> println("x is a prime number between 1 and 10.")
        7 -> println("x is a prime number between 1 and 10.")
    }
}
  1. 添加一个else分支，其中包含一个println("x is not prime number between 1 and 10.")主体。
fun main() {
    val x = 3

    when (x) {
        2 -> println("x is a prime number between 1 and 10.")
        3 -> println("x is a prime number between 1 and 10.")
        5 -> println("x is a prime number between 1 and 10.")
        7 -> println("x is a prime number between 1 and 10.")
        else -> println("x isn't a prime number between 1 and 10.")
    }
}
  1. 运行程序，然后验证输出是否符合预期。
x is a prime number between 1 and 10.

使用逗号（,）处理多个条件

素数程序包含许多println()语句的重复。当编写when语句时，可以使用逗号（,）来表示对应于相同代码块的多个条件。

A diagram that shows the anatomy of a when statement. It starts with a when keyword followed by parentheses with a parameter block inside them. Next, inside a pair curly braces, there are two lines of cases. On the first line, there's a condition 1 block followed by a comma, followed by a condition 2 block followed by an arrow symbol and a body block. On the second line, there's a condition block followed by an arrow symbol and a body block.

在上图中，如果第一个或第二个条件成立，则执行相应的代码块。

使用这个概念重写素数程序。

  1. 在2条件的分支中，添加3、5和7，并用逗号（,）分隔。
fun main() {
    val x = 3

    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        3 -> println("x is a prime number between 1 and 10.")
        5 -> println("x is a prime number between 1 and 10.")
        7 -> println("x is a prime number between 1 and 10.")
        else -> println("x isn't a prime number between 1 and 10.")
    }
}
  1. 移除3、5和7条件的各个分支。
fun main() {
    val x = 3

    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        else -> println("x isn't a prime number between 1 and 10.")
    }
}
  1. 运行程序，然后验证输出是否符合预期。
x is a prime number between 1 and 10.

使用in **关键字表示一系列条件**。

除了用逗号（,）表示多个条件外，还可以使用in关键字和when分支中的一个值范围。

A diagram that shows the anatomy of a when statement. It starts with a when keyword followed by parentheses with a parameter block inside them. Next, inside a pair curly braces, there are two lines of cases. On the first line, there's an in keyword followed by a range start block, two dots, a range end block, an arrow symbol, and then a body block. On the second line, there's a condition block followed by an arrow symbol and a body block.

要使用值范围，请添加一个表示范围开始的数字，后跟两个句点（没有空格），然后用另一个表示范围结束的数字关闭。

当参数的值等于范围开始和范围结束之间的任何值时，第一个代码块将执行。

在你的素数程序中，如果数字在1到10之间但不是素数，你能打印一条消息吗？

添加另一个带有in关键字的分支。

  1. 在when语句的第一个分支之后，添加第二个分支，其中包含in关键字，后跟1..10范围和println("x is a number between 1 and 10, but not a prime number.")代码块。
fun main() {
    val x = 3

    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        in 1..10 -> println("x is a number between 1 and 10, but not a prime number.")
        else -> println("x isn't a prime number between 1 and 10.")
    }
}
  1. 将x变量更改为4值。
fun main() {
    val x = 4

    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        in 1..10 -> println("x is a number between 1 and 10, but not a prime number.")
        else -> println("x isn't a prime number between 1 and 10.")
    }
}
  1. 运行程序，然后验证输出。
x is a number between 1 and 10, but not a prime number.

程序打印第二个分支的消息，但不打印第一个或第三个分支的消息。

bde4eca467c105a2.png

以下是此程序的工作原理。

  • x变量被赋值为4值。
  • 程序继续评估第一个分支的条件。4值不是2、3、5或7值，因此程序跳过第一个分支代码块的执行，并继续执行第二个分支。
  • 4值介于1和10之间，因此打印x is a number between 1 and 10, but not a prime number.代码块的消息。
  • 执行了一个代码块，因此程序继续离开when语句并忽略else分支。

使用is关键字检查数据类型。

可以使用is关键字作为条件来检查被评估值的数 据类型。

A diagram that shows the anatomy of a when statement. It starts with a when keyword followed by parentheses with a parameter block inside them. Next, inside a pair curly braces, there are two lines of cases. On the first line, there is an in keyword followed by a type block, an arrow symbol, and then a body block. On the second line, there's a condition block followed by an arrow symbol and then a body block.

在上图中，如果参数的值是声明的数据类型，则执行第一个代码块。

在你的素数程序中，如果输入是一个不在1到10范围内的整数，你能打印一条消息吗？

添加另一个带有is关键字的分支。

  1. 修改x的类型为Any。这表示x可以是Int类型以外的值。
fun main() {
    val x: Any = 4

    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        in 1..10 -> println("x is a number between 1 and 10, but not a prime number.")
        else -> println("x isn't a prime number between 1 and 10.")
    }
}
  1. 在when语句的第二个分支之后，添加is关键字和Int数据类型，以及println("x is an integer number, but not between 1 and 10.")代码块。
fun main() {
    val x: Any = 4

    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        in 1..10 -> println("x is a number between 1 and 10, but not a prime number.")
        is Int -> println("x is an integer number, but not between 1 and 10.")
        else -> println("x isn't a prime number between 1 and 10.")
    }
}
  1. 在else分支中，将代码块更改为println("x isn't an integer number.")代码块。
fun main() {
    val x: Any = 4

    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        in 1..10 -> println("x is a number between 1 and 10, but not a prime number.")
        is Int -> println("x is an integer number, but not between 1 and 10.")
        else -> println("x isn't an integer number.")
    }
}
  1. 将x变量更改为20值。
fun main() {
    val x: Any = 20

    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        in 1..10 -> println("x is a number between 1 and 10, but not a prime number.")
        is Int -> println("x is an integer number, but not between 1 and 10.")
        else -> println("x isn't an integer number.")
    }
}
  1. 运行程序，然后验证输出。
x is an integer number, but not between 1 and 10.

程序打印第三个分支的消息，但不打印第一个、第二个或第四个分支的消息。

1255c101845f9247.png

以下是程序的工作原理。

  • x变量被赋值为20值。
  • 程序继续评估第一个分支的条件。20值不是2、3、5或7值，因此程序跳过第一个分支代码块的执行，并继续执行第二个分支。
  • 20值不在1到10范围内，因此程序跳过第二个分支代码块的执行，并继续执行第三个分支。
  • 20值是Int类型，因此打印x is an integer number, but not between 1 and 10代码块。
  • 执行了一个代码块，因此程序继续离开when语句并忽略else分支。

试试看

现在在你的交通灯程序中练习你学到的知识。

想象一下，在一些国家，琥珀色的交通灯颜色与其他国家黄色的交通灯一样警告司机。你能修改程序以涵盖此附加条件并保持原始条件吗？

添加一个具有相同代码块的附加条件。

向交通灯程序添加一个附加条件。

  1. 如果你仍然打开它，请返回包含你的交通灯程序的Kotlin Playground实例。
  2. 如果你关闭了它，请打开一个新的Kotlin Playground实例并输入此代码。
fun main() {
    val trafficLightColor = "Yellow"

    when (trafficLightColor) {
        "Red" -> println("Stop")
        "Yellow" -> println("Slow")
        "Green" -> println("Go")
        else -> println("Invalid traffic-light color")
    }
}
  1. 在when语句的第二个分支中，在"Yellow"条件之后添加一个逗号，然后添加"Amber"条件。
fun main() {
    val trafficLightColor = "Yellow"

    when (trafficLightColor) {
        "Red" -> println("Stop")
        "Yellow", "Amber" -> println("Slow")
        "Green" -> println("Go")
        else -> println("Invalid traffic-light color")
    }
}
  1. 将trafficLightColor变量更改为"Amber"值。
fun main() {
    val trafficLightColor = "Amber"

    when (trafficLightColor) {
        "Red" -> println("Stop")
        "Yellow", "Amber" -> println("Slow")
        "Green" -> println("Go")
        else -> println("Invalid traffic-light color")
    }
}
  1. 运行此程序，然后验证输出。
Slow

4. 使用if/else和when作为表达式

你学习了如何使用if/else和when作为语句。当使用条件语句时，你可以让每个分支根据条件在其代码块中执行不同的操作。

你还可以使用条件表达式为每个条件分支返回不同的值。当每个分支的代码块看起来相似时，与条件语句相比，可以使用条件表达式来提高代码的可读性。

A diagram that describes an if/else expression with the val keyword followed by a name block, an equal symbol, an if keyword, parentheses with a condition inside them, a pair of curly braces with a body 1 block inside them, an else keyword, and then a pair of curly braces with a body block inside them.

条件表达式与语句的语法相似，但每个分支的最后一行代码需要返回一个值或表达式，并且条件表达式被赋值给一个变量。

如果代码块只包含返回值或表达式，可以移除花括号以使代码更简洁。

A diagram that describes an if/else expression with the val keyword followed by a name block, an equal symbol, an if keyword, parentheses with a condition inside them, an expression 1 block, an else keyword, and then an expression 2 block.

在下一节中，你将通过交通灯程序了解if/else表达式。

将if语句转换为表达式。

此if/else语句中有很多println()语句重复。

fun main() {
    val trafficLightColor = "Black"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else if (trafficLightColor == "Yellow") {
        println("Slow")
    } else if (trafficLightColor == "Green") {
        println("Go")
    } else {
        println("Invalid traffic-light color")
    }

}

将此if/else语句转换为if/else表达式并删除此重复。

  1. 在Kotlin Playground中，输入之前的交通灯程序。
  2. 定义一个message变量，然后为其赋值一个if/else语句。
fun main() {
    val trafficLightColor = "Black"

    val message = if (trafficLightColor == "Red") {
        println("Stop")
    } else if (trafficLightColor == "Yellow") {
        println("Slow")
    } else if (trafficLightColor == "Green") {
        println("Go")
    } else {
        println("Invalid traffic-light color")
    }

}
  1. 删除所有println()语句及其花括号，但保留其中的值。
fun main() {
    val trafficLightColor = "Black"

    val message = 
      if (trafficLightColor == "Red") "Stop"
      else if (trafficLightColor == "Yellow") "Slow"
      else if (trafficLightColor == "Green") "Go"
      else "Invalid traffic-light color"
}
  1. 在程序末尾添加一个println()语句，然后将其作为参数传递message变量。
fun main() {
    val trafficLightColor = "Black"

    val message = 
      if (trafficLightColor == "Red") "Stop"
      else if (trafficLightColor == "Yellow") "Slow"
      else if (trafficLightColor == "Green") "Go"
      else "Invalid traffic-light color"

    println(message)
}
  1. 运行此程序，然后查看输出。
Invalid traffic-light color

试试看

转换交通灯程序以使用when表达式而不是when语句。

  1. 在Kotlin Playground中，输入此代码。
fun main() {
    val trafficLightColor = "Amber"

    when (trafficLightColor) {
        "Red" -> println("Stop")
        "Yellow", "Amber" -> println("Slow")
        "Green" -> println("Go")
        else -> println("Invalid traffic-light color")
    }
}

你能将when语句转换为表达式，以便你无需重复println()语句吗？

  1. 创建一个message变量并将其赋值给when表达式。
fun main() {
    val trafficLightColor = "Amber"

    val message = when(trafficLightColor) {
        "Red" -> "Stop"
        "Yellow", "Amber" -> "Slow"
        "Green" -> "Go"
        else -> "Invalid traffic-light color"
    }
}
  1. 添加一个println()语句作为程序的最后一行，然后将其作为参数传递message变量。
fun main() {
    val trafficLightColor = "Amber"

    val message = when(trafficLightColor) {
        "Red" -> "Stop"
        "Yellow", "Amber" -> "Slow"
        "Green" -> "Go"
        else -> "Invalid traffic-light color"
    }
    println(message)
}

5. 结论

恭喜！你学习了条件语句以及如何在Kotlin中编写它们。

总结

  • 在Kotlin中，分支可以使用if/else或when条件语句来实现。
  • 仅当if/else条件语句中if分支内的布尔表达式返回true值时，才执行if分支的代码块。
  • if/else条件语句中的后续else if分支仅在之前的if或else if分支返回false值时才执行。
  • if/else条件语句中的最终else分支仅在所有之前的if或else if分支返回false值时才执行。
  • 当有多于两个分支时，建议使用when条件语句来替换if/else条件语句。
  • 您可以使用逗号 (,)、范围 (in) 和 is 关键字在 when 条件语句中编写更复杂的条件。
  • if/else 和 when 条件语句可以作为语句或表达式。

了解更多