在 Kotlin 中编写条件语句

1. 开始之前

条件语句是编程最重要的基础之一。条件语句是编程语言中处理决策的命令。使用条件语句，代码是动态的，这意味着它可以在给定不同条件的情况下表现出不同的行为。

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

先决条件

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

您将学到什么

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

您需要什么

  • 一个可以访问 Kotlin Playground 的网络浏览器

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 消息。

试试看

你注意到当前程序包含一个错误了吗？

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

假设你只希望驾驶员在交通灯颜色为绿色时才驾驶。如果交通灯坏了并熄灭了怎么办？你希望驾驶员驾驶还是收到警告说出了问题？

不幸的是，在当前程序中，如果交通灯颜色除红色或黄色之外的任何其他颜色，仍然建议驾驶员通行。

修复此问题

  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 语句，因为它提高了可读性，可读性指的是人类读者（通常是开发者）阅读代码的难易程度。在编写代码时考虑可读性非常重要，因为其他开发人员很可能需要在代码的整个生命周期中审查和修改你的代码。良好的可读性确保开发人员能够正确理解你的代码，并且不会无意中引入错误。

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

了解更多