【100天学习SwiftUI】第5天 If、switch 和三元运算符

如何检查条件是真还是假
程序经常做出选择：

如果学生的考试成绩超过 80 分，则打印成功消息。

如果用户输入的名字按字母顺序排在朋友的名字后面，则将朋友的名字放在前面。

如果向数组添加一个数字使其包含超过 3 个项目，请删除最旧的一项。

如果用户被要求输入姓名但没有输入任何内容，则为他们提供默认名称“匿名”。

Swift 处理这些 withif语句，让我们检查条件并在条件为真时运行一些代码。它们看起来像这样：

if someCondition {    print("Do something")}

让我们来分解一下：

条件以 开头if，这向 Swift 发出信号，表明我们想要检查代码中的某种条件。

这someCondition部分是你写条件的地方——分数超过80了吗？数组是否包含超过 3 个项目？

如果条件为真（如果分数确实超过80），那么我们会打印“做某事”消息。

当然，这并不是代码中的全部内容{：我没有提到小和}符号。这些被称为大括号——更具体地说，是左大括号和右大括号——尽管有时您会听到它们被称为“大括号”或“花括号”。

这些大括号在 Swift 中广泛用于标记代码块：左大括号开始代码块，右大括号结束代码块。代码块内部是我们想要运行的所有代码（如果我们的条件在检查时恰好为真），在我们的例子中是打印一条消息。

您可以在其中包含任意数量的代码：

if someCondition {    print("Do something")    print("Do something else")    print("Do a third thing")}

当然，真正重要的是这someCondition部分，因为这就是您的检查代码的用武之地：您实际上想要检查什么条件？

好吧，让我们尝试一下分数示例：如果一个score常量超过 80，我们就打印一条消息。代码如下：

let score = 85  if score > 80 {    print("Great job!")}

在该代码中，score > 80是我们的条件。您会记得>学校里的意思是“大于”，所以我们的完整条件是“如果分数大于 80”。如果大于80，“干得好！” 将被打印——很好！

该>符号是一个比较运算符，因为它比较两个事物并返回一个布尔结果：左侧的事物是否大于右侧的事物？您还可以使用“<小于”、>=“大于或等于”和<=“小于或等于”。

让我们尝试一下——你认为这段代码会打印什么？

let speed = 88let percentage = 85let age = 18if speed >= 88 {    print("Where we're going we don't need roads.")}if percentage < 85 {    print("Sorry, you failed the test.")}if age >= 18 {    print("You're eligible to vote")}

尝试在脑海中运行代码 – 哪些print()行将实际运行？

speed好吧，如果大于或等于 88，我们的第一个代码将运行，并且因为它恰好print()是 88 ，所以将运行第一个代码。

percentage如果小于 85，第二个将运行，并且因为它恰好是 85，所以第二个print()将不会运行 - 我们使用小于，而不是小于或等于。

age如果大于或等于 18，则第三个将运行，并且因为它恰好是 18，所以第三个print() 将运行。

现在让我们尝试第二个示例条件：如果用户输入的姓名按字母顺序位于朋友姓名之后，则将朋友的姓名放在前面。您已经了解了<、>=和其他代码如何很好地处理数字，但它们也同样可以很好地处理开箱即用的字符串：

let ourName = "Dave Lister"let friendName = "Arnold Rimmer"if ourName < friendName {    print("It's \(ourName) vs \(friendName)")}if ourName > friendName {    print("It's \(friendName) vs \(ourName)")}

因此，如果按字母顺序排序时，内部字符串ourName位于内部字符串之前friendName，则它首先打印ourNamethen friendName，这正是我们想要的。

让我们看一下第三个示例条件：如果向数组添加一个数字使其包含超过 3 个项目，则删除最旧的一个。您已经遇到了append()、count和remove(at:)，因此我们现在可以将这三个条件放在一起，如下所示：

// Make an array of 3 numbersvar numbers = [1, 2, 3]// Add a 4thnumbers.append(4)// If we have over 3 itemsif numbers.count > 3 {    // Remove the oldest number    numbers.remove(at: 0)}// Display the resultprint(numbers)

现在让我们看看第四个示例条件：如果用户被要求输入他们的姓名并且什么也没输入，则给他们一个默认名称“Anonymous”。

要解决这个问题，您首先需要遇到两个您将经常使用的其他比较运算符，它们都处理相等性。第一个是==“等于”，用法如下：

let country = "Canada"if country == "Australia" {    print("G'day!")}

第二个是!=，意思是“不等于”，用法如下：

let name = "Taylor Swift"if name != "Anonymous" {    print("Welcome, \(name)")}

在我们的例子中，我们想要检查用户输入的用户名是否为空，我们可以这样做：

// Create the username variablevar username = "taylorswift13"// If `username` contains an empty stringif username == "" {    // Make it equal to "Anonymous"    username = "Anonymous"}// Now print a welcome messageprint("Welcome, \(username)!")

这""是一个空字符串：我们开始字符串并结束字符串，中间没有任何内容。通过比较username，我们检查用户是否还为其用户名输入了空字符串，这正是我们想要的。

现在，还有其他方法可以进行此检查，了解它们的作用很重要。

首先，我们可以将count字符串的（它有多少个字母）与 0 进行比较，如下所示：

if username.count == 0 {    username = "Anonymous"}

在任何语言中，将一个字符串与另一个字符串进行比较都不是很快，因此我们将字符串比较替换为整数比较：字符串中的字母数是否等于 0？

在许多语言中这都非常快，但在 Swift 中则不然。你看，Swift 支持各种复杂的字符串——实际上每种人类语言都可以开箱即用，包括表情符号，但在许多其他编程语言中却并非如此。然而，这种真正伟大的支持是有代价的，其中一部分代价是，询问一个字符串会让countSwift 遍历并一一计算所有字母——它不只是将其长度与字符串分开存储。

因此，考虑一下这样的情况：您有一个巨大的字符串来存储莎士比亚的全集。我们的小检查count == 0必须遍历并计算字符串中的所有字母，尽管一旦我们计算了至少一个字符，我们就知道问题的答案。

因此，Swift 为其所有字符串、数组、字典和集合添加了第二个功能：isEmpty. true如果您正在检查的东西里面没有任何内容，这将发回，我们可以使用它来修复我们的情况，如下所示：

if username.isEmpty == true {    username = "Anonymous"}

这样更好，但我们还可以更进一步。你看，最终重要的是你的条件必须归结为真或假；斯威夫特不允许任何其他事情。在我们的例子中，username.isEmpty已经是一个布尔值，这意味着它将是 true 或 false，所以我们可以使我们的代码更加简单：

if username.isEmpty {    username = "Anonymous"}

如果isEmpty为真，则条件通过并username设置为匿名，否则条件失败。

Swift 如何让我们比较多种类型的数据？
Swift 允许我们开箱即用地比较多种值，这意味着我们可以检查多种值的相等性和比较。例如，如果我们有如下值：

let firstName = "Paul"let secondName = "Sophie"let firstAge = 40let secondAge = 10

然后我们可以通过多种方式比较它们：

print(firstName == secondName)print(firstName != secondName)print(firstName < secondName)print(firstName >= secondName)print(firstAge == secondAge)print(firstAge != secondAge)print(firstAge < secondAge)print(firstAge >= secondAge)

在幕后，Swift 以一种非常聪明的方式实现了这一点，实际上允许它比较各种各样的事物。例如，Swift 有一种用于存储日期的特殊类型，称为Date，您可以使用相同的运算符来比较日期： someDate < someOtherDate例如。

我们甚至可以要求 Swift 使我们的枚举具有可比性，如下所示：

enum Sizes: Comparable {    case small    case medium    case large}let first = Sizes.smalllet second = Sizes.largeprint(first < second)

这将打印“true”，因为在枚举案例列表中small位于前面。large

如何检查多个条件
当我们使用时，if我们必须向 Swift 提供某种条件，一旦被评估，该条件要么为真，要么为假。如果您想检查多个不同的值，可以将它们一个接一个地放置，如下所示：

let age = 16if age >= 18 {    print("You can vote in the next election.")}if age < 18 {    print("Sorry, you're too young to vote.")}

然而，如果你仔细想想，这并不是很有效：我们的两个条件是互斥的，因为如果有人大于或等于 18（第一个条件），那么他们就不能小于 18（第二个条件），并且反之亦然。我们让 Swift 做一些不需要的工作。

在这种情况下，Swift 为我们提供了一个更高级的条件，让我们可以else在代码中添加一个块——如果条件不成立则运行一些代码。

使用else我们可以将之前的代码重写为：

let age = 16if age >= 18 {    print("You can vote in the next election.")} else {    print("Sorry, you're too young to vote.")}

现在 Swift 只需检查age一次：如果它大于或等于 18，print()则运行第一个代码，但如果它是小于print()18 的任何值，则运行第二个代码。

所以，现在我们的情况是这样的：

if someCondition {    print("This will run if the condition is true")} else {    print("This will run if the condition is false")}

还有一个更高级的条件，称为else if，它允许您在第一个检查失败时运行新的检查。如果需要，您可以只拥有其中之一，也可以拥有多个else if，甚至可以根据需要else if与组合。else然而，你只能拥有一个else，因为这意味着“如果所有其他条件都为假”。

看起来是这样的：

let a = falselet b = trueif a {    print("Code to run if a is true")} else if b {    print("Code to run if a is false but b is true")} else {    print("Code to run if both a and b are false")}

如果您愿意，您可以继续添加越来越多的else if条件，但请注意您的代码不要变得太复杂！

除了使用else和else if来创建更高级的条件外，您还可以检查不止一件事。例如，我们可能想说“如果今天的温度超过 20 摄氏度但低于 30 摄氏度，请打印一条消息。”

这有两个条件，所以我们可以这样写：

let temp = 25if temp > 20 {    if temp < 30 {        print("It's a nice day.")    }}

虽然这工作得很好，但 Swift 提供了一个更短的替代方案：我们可以用来&&将两个条件组合在一起，并且只有当条件内的两个部分都为 true 时，整个条件才会为 true。

因此，我们可以将代码更改为：

if temp > 20 && temp < 30 {    print("It's a nice day.")}

你应该读作&&“and”，所以我们的整个条件是“如果 temp 大于 20 并且 temp 小于 30，则打印一条消息。” 它被称为逻辑运算符，因为它将布尔值组合起来形成一个新的布尔值。

&&对应的是两个管道符号 ，||表示“或”。仅&&当两个子条件都为真时才会使条件为真，而如果任一子||条件为真则使条件为真。

例如，我们可以说，如果用户年满 18 岁，则可以购买游戏，或者如果用户未满 18 岁，则必须获得父母的许可。||我们可以这样写：

let userAge = 14let hasParentalConsent = trueif userAge >= 18 || hasParentalConsent == true {    print("You can buy the game")}

这将打印“你可以购买游戏”，因为虽然我们的条件前半部分失败——用户未满18岁——但后半部分通过，因为他们确实得到了父母的同意。

请记住，== true可以删除条件中的使用，因为我们显然已经在检查布尔值。所以，我们可以这样写：

if userAge >= 18 || hasParentalConsent {    print("You can buy the game")}

为了完成检查多个条件，让我们尝试一个更复杂的示例，它同时组合if、else if、else和，甚至展示枚举如何适应条件。||

在此示例中，我们将创建一个名为 的枚举TransportOption，其中包含五种情况：飞机、直升机、自行车、汽车和踏板车。然后，我们将给常量分配一个示例值，并运行一些检查：

如果我们乘飞机或直升机去某个地方，我们会打印“Let's Fly！”

如果我们骑自行车去，我们会打印“我希望有一条自行车道......”

如果我们开车去，我们会打印“交通堵塞时间到了”。

否则我们会打印“我现在要租一辆踏板车！”

这是代码：

enum TransportOption {    case airplane, helicopter, bicycle, car, scooter}let transport = TransportOption.airplaneif transport == .airplane || transport == .helicopter {    print("Let's fly!")} else if transport == .bicycle {    print("I hope there's a bike path…")} else if transport == .car {    print("Time to get stuck in traffic.")} else {    print("I'm going to hire a scooter now!")}

我想挑选出该代码的几个部分：

当我们设置 的值时，transport我们需要明确我们所指的是TransportOption.airplane。我们不能只写.airplane，因为 Swift 不理解我们的意思是TransportOption枚举。

一旦发生这种情况，我们就不需要TransportOption再编写任何内容，因为 Swift 知道transport必须是某种TransportOption. 因此，我们可以检查它是否等于.airplane而不是TransportOption.airplane。

该代码用于||检查是否transport等于.airplane 或等于.helicopter，如果其中任何一个为真，则条件为真，然后“让我们飞吧！” 被打印。

如果第一个条件失败 – 如果传输模式不是.airplane或.helicopter– 则运行第二个条件：传输模式是.bicycle？如果是这样，则会打印“我希望有一条自行车道......”。

如果我们也不骑自行车去，那么我们会检查是否要开车去。如果是的话，“是时候陷入交通堵塞了。” 被打印。

最后，如果前面的所有条件都失败，则该else块将运行，这意味着我们将乘坐踏板车。

if 和 else if 有什么区别？
当您刚刚学习 Swift 时，可能会有点难以知道何时使用else、何时使用else if以及真正的区别是什么。

好吧，让我们从一个可以使用的示例值开始：

let score = 9001

（如果你想知道，是的，这确实意味着我们将依赖《龙珠 Z》模因。）

我们可以编写一个简单的条件来检查分数是否超过 9000，如下所示：

if score > 9000 {    print("It's over 9000!")}

现在，如果我们想为等于或低于 9000 的分数打印不同的消息，我们可以这样写：

if score > 9000 {    print("It's over 9000!")}if score <= 9000 {    print("It's not over 9000!")}

效果非常好，您的代码将完全按照您的预期进行。但现在我们给了 Swift 更多的工作要做：它需要检查score两次的值。对于一个简单的整数来说，速度非常快，但如果我们的数据更复杂，那么速度会更慢。

这就是else出现的地方，因为它意味着“如果我们检查的条件不成立，则运行此代码。”

因此，我们可以将之前的代码重写为：

if score > 9000 {    print("It's over 9000!")} else {    print("It's not over 9000!")}

通过这一更改，Swift 将只检查score一次，而且我们的代码也更短且更易于阅读。

现在假设我们想要三条消息：一条当分数超过 9000 时，一条当分数恰好为 9000 时，一条当分数低于 9000 时。我们可以这样写：

if score > 9000 {    print("It's over 9000!")} else {    if score == 9000 {        print("It's exactly 9000!")    } else {        print("It's not over 9000!")    }}

再说一次，这完全没问题，并且正如您所希望的那样工作。但是，我们可以使用 使代码更易于阅读else if，这让我们可以将else与if紧随其后的 结合起来，如下所示：

if score > 9000 {    print("It's over 9000!")} else if score == 9000 {    print("It's exactly 9000!")} else {    print("It's not over 9000!")}

为了尝试这个，我想使用一个名为 的 Swift 函数print()：你用一些文本运行它，它将被打印出来。

这使得我们的代码更容易阅读和理解，因为我们没有嵌套条件，而是有一个可以向下阅读的流程。

您可以拥有else if任意数量的支票，但您只需要 1 个if，或者 0 或 1 else。

如何检查多个条件
Swift 为我们提供了&&and||来同时检查多个条件，当仅与两个条件一起使用时，它们相当简单。

举个例子，假设我们正在运行一个论坛，用户可以在其中发布消息，并删除他们拥有的任何消息。我们可能会写这样的代码：

if isOwner == true || isAdmin == true {    print("You can delete this post")}

当我们想要检查几件事时，事情会变得更加混乱。例如，我们可以说普通用户只有在我们允许的情况下才能删除消息，但管理员始终可以删除帖子。我们可能会写这样的代码：

if isOwner == true && isEditingEnabled || isAdmin == true {    print("You can delete this post")}

但这是想检查什么？&&和检查的执行顺序是什么||？这可能意味着：

if (isOwner == true && isEditingEnabled) || isAdmin == true {    print("You can delete this post")}

也就是说，“如果我们是所有者并且启用了编辑功能，您可以删除该帖子，或者如果您是管理员，即使您不拥有该帖子，也可以删除该帖子。” 这是有道理的：如果允许编辑，人们可以删除自己的帖子，但管理员始终可以删除帖子。

但是，您也可以这样阅读：

if isOwner == true && (isEditingEnabled || isAdmin == true) {    print("You can delete this post")}

现在它的含义完全不同：“如果您是帖子的所有者，并且启用了编辑功能或者您是管理员，那么您可以删除帖子。” 这意味着管理员无法删除不属于他们的帖子，这是没有意义的。

显然 Swift 不喜欢这样的歧义，所以它总是会解释代码，就好像我们写了这样：

if (isOwner == true && isEditingEnabled) || isAdmin == true {    print("You can delete this post")}

然而，老实说，让 Swift 来解决这个问题并不是一个很好的体验，这就是为什么我们可以自己插入括号来明确我们的意思。

对此没有具体的建议，但实际上任何时候你混合&&并且||在单一条件下你几乎肯定应该使用括号来使结果清晰。

如何使用switch语句检查多个条件
您可以根据需要多次使用ifand来检查条件，但它有点难以阅读。else if例如，如果我们有一个来自枚举的天气预报，我们可以根据一系列条件选择要打印的消息，如下所示：

enum Weather {    case sun, rain, wind, snow, unknown}let forecast = Weather.sunif forecast == .sun {    print("It should be a nice day.")} else if forecast == .rain {    print("Pack an umbrella.")} else if forecast == .wind {    print("Wear something warm")} else if forecast == .snow {    print("School is cancelled.")} else {    print("Our forecast generator is broken!")}

这可行，但有问题：

forecast即使我们每次都检查相同的内容，我们仍然必须编写。

我不小心检查了.rain两次，尽管第二次检查永远不可能为真，因为只有第一次检查失败时才会执行第二次检查。

.snow我根本没有检查，所以我们缺少功能。

我们可以使用一种不同的检查条件的方法（称为 ）来解决所有这三个问题switch。这也让我们可以一一检查个别情况，但现在 Swift 可以提供帮助。对于枚举，它知道枚举可能具有的所有可能情况，因此如果我们错过一个或检查一个两次，它就会抱怨。

因此，我们可以用以下内容替换所有这些if和else if检查：

switch forecast {case .sun:    print("It should be a nice day.")case .rain:    print("Pack an umbrella.")case .wind:    print("Wear something warm")case .snow:    print("School is cancelled.")case .unknown:    print("Our forecast generator is broken!")}

让我们来分解一下：

我们从 开始switch forecast，它告诉 Swift 这就是我们要检查的值。

然后我们有一串case语句，每个语句都是我们要与之比较的值forecast。

我们的每个案例都列出了一种天气类型，并且因为我们正在打开，所以forecast我们不需要编写Weather.sun，Weather.rain等等 - Swift 知道它一定是某种Weather。

在每个案例之后，我们编写一个冒号来标记如果该案例匹配则要运行的代码的开始。

我们使用右大括号来结束switch语句。

如果你尝试改变.snowfor .rain，你会看到 Swift 大声抱怨：一旦我们检查了.rain两次，我们的switch声明并不详尽——它不能处理所有可能的情况。

如果你曾经使用过其他编程语言，你可能会注意到 Swift 的switch声明有两个地方不同：

所有switch语句都必须详尽无遗，这意味着必须在其中处理所有可能的值，这样您就不会意外地遗漏其中一个。

Swift 将执行第一个与您正在检查的条件匹配的情况，但不再执行。其他语言通常会继续执行所有后续情况中的其他代码，这通常是完全错误的默认操作。

尽管这两种说法都是正确的，但如果我们需要的话，Swift 会为我们提供更多的控制权。

首先，是的，所有switch陈述都必须详尽：您必须确保涵盖所有可能的值。如果您要打开一个字符串，那么显然不可能对所有可能的字符串进行详尽的检查，因为字符串的数量是无限的，因此我们需要提供一个默认情况 - 如果没有其他情况匹配，则运行代码。

例如，我们可以切换包含地名的字符串：

let place = "Metropolis"switch place {case "Gotham":    print("You're Batman!")case "Mega-City One":    print("You're Judge Dredd!")case "Wakanda":    print("You're Black Panther!")default:    print("Who are you?")}

最后default:是默认情况，如果所有情况都无法匹配，则将运行该情况。

请记住：Swift 按顺序检查其大小写并运行第一个匹配的大小写。如果您将其放在default任何其他情况之前，则该情况是无用的，因为它永远不会匹配，并且 Swift 将拒绝构建您的代码。

其次，如果您明确希望Swift 继续执行后续案例，请使用fallthrough. 这并不常用，但有时（只是有时）它可以帮助您避免重复工作。

例如，有一首著名的圣诞歌曲，名叫《圣诞节的十二天》，随着歌曲的继续，越来越多的礼物被堆积在一个不幸的人身上，而到了第六天，他已经满屋子了。

我们可以使用这首歌做一个简单的近似fallthrough。首先，如果没有以下 代码，代码将如下所示fallthrough：

let day = 5print("My true love gave to me…")switch day {case 5:    print("5 golden rings")case 4:    print("4 calling birds")case 3:    print("3 French hens")case 2:    print("2 turtle doves")default:    print("A partridge in a pear tree")}

这将打印“5 Golden Rings”，这不太正确。第 1 天只应打印“梨树上的鹧鸪”，第 2 天应打印“2 只斑鸠” ，然后“梨树上的鹧鸪”，第 3 天应打印“3 只法国母鸡”，“两只斑鸠”，而且……好吧，你明白了。

我们可以使用fallthrough以下方法来准确获得该行为：

let day = 5print("My true love gave to me…")switch day {case 5:    print("5 golden rings")    fallthroughcase 4:    print("4 calling birds")    fallthroughcase 3:    print("3 French hens")    fallthroughcase 2:    print("2 turtle doves")    fallthroughdefault:    print("A partridge in a pear tree")}

这将匹配第一个案例并打印“5 Golden Rings”，但该fallthrough行意味着case 4将执行并打印“4 Calling Birds”，这又会fallthrough再次使用，以便打印“3 French hens”，依此类推。它与歌曲并不完美匹配，但至少您可以看到实际的功能！

什么时候应该使用 switch 语句而不是 if ？
Swift 开发人员可以同时使用switch和if来检查代码中的多个值，并且通常没有什么硬性理由说明为什么您应该选择其中一个而不是另一个。话虽这么说，您可能想考虑使用switch而不是使用以下三个原因if：

Swift 要求其switch语句是详尽的，这意味着您必须case为每个可能的值检查一个块（例如枚举的所有情况），或者您必须有一个default情况。if对于和来说情况并非如此else if，因此您可能会意外地错过某个案例。

当您用于switch检查一个值是否有多个可能的结果时，该值只会被读取一次，而如果您使用它，if它将被读取多次。当您开始使用函数调用时，这一点变得更加重要，因为其中一些函数调用可能会很慢。

Swift 的switch情况允许进行高级模式匹配，而这对于if.

还有一种情况，但它有点模糊：从广义上讲，如果你想检查三个或更多可能状态的相同值，你会发现人们更喜欢使用switch而不是if出于易读性的目的，如果没有其他的话 - 更清楚的是我们重复检查相同的值，而不是编写不同的条件。

PS：我已经介绍了这个fallthrough关键字，因为它对于来自其他编程语言的人来说很重要，但在 Swift 中很少看到它使用 – 如果您正在努力想出它可能有用的场景，请不要担心，因为老实说，大多数时候事实并非如此！

如何使用三元条件运算符进行快速测试
在 Swift 中还有最后一种检查条件的方法，当您看到它时，您很可能会想知道它何时有用。公平地说，很长一段时间我很少使用这种方法，但正如您稍后会看到的，它对于 SwiftUI 来说非常重要。

该选项称为三元条件运算符。要理解为什么它有这个名字，您首先需要知道+、-、==等都称为二元运算符，因为它们适用于两个输入：2 + 5例如，适用于 2 和 5。

三元运算符处理三个输入，事实上，因为三元条件运算符是 Swift 中唯一的三元运算符，所以您经常会听到它被称为“三元运算符”。

无论如何，关于名称已经足够了：这实际上是做什么的？好吧，三元运算符让我们检查条件并返回两个值之一：如果条件为 true，则返回某个值；如果条件为 false，则返回某个值。

例如，我们可以创建一个名为 的常量age来存储某人的年龄，然后创建第二个常量名为canVote来存储该人是否能够投票：

let age = 18let canVote = age >= 18 ? "Yes" : "No"

当该代码运行时，canVote将设置为“是”，因为age设置为 18。

正如您所看到的，三元运算符分为三个部分：检查 ( age >= 18)、条件为 true 时的部分（“Yes”）和条件为 false 时的部分（“No”）。if这使得它与常规else块完全一样，并且顺序相同。

如果有帮助的话，Scott Michaud建议了一个有用的助记符：WTF。它代表“什么、真、假”，并且与我们代码的顺序相匹配：

我们的条件是什么？嗯，是的age >= 18。

当条件成立时该怎么办？发送回“是”，这样就可以将其存储在canVote.

如果条件为假呢？回复“否”。

让我们看一些其他示例，从一个简单的示例开始，它以 24 小时格式读取一小时并打印两条消息之一：

let hour = 23print(hour < 12 ? "It's before noon" : "It's after noon")

请注意，它不会将结果分配到任何地方 - true 或 false 情况只是根据 的值打印hour。

或者，这里读取count数组的 ，作为其条件的一部分，然后发回两个字符串之一：

let names = ["Jayne", "Kaylee", "Mal"]   let crewCount = names.isEmpty ? "No one" : "\(names.count) people"print(crewCount)

当您的条件用于检查相等性时，它会变得有点难以阅读==，如下所示：

enum Theme {    case light, dark}let theme = Theme.darklet background = theme == .dark ? "black" : "white"print(background)

这= theme ==部分通常是人们觉得难以阅读的部分，但请记住将其分解：

什么？theme == .dark

正确：“黑色”

错误：“白色”

因此，如果 theme 等于.dark返回“Black”，否则返回“White”，则将其分配给background.

现在，您可能想知道为什么三元运算符很有用，特别是当我们有可用的常规if/else条件时。我意识到这不是一个很好的答案，但你必须相信我：有时，特别是使用 SwiftUI，我们别无选择，必须使用三元。

您可以通过我们检查时间的代码大致了解问题所在：

let hour = 23print(hour < 12 ? "It's before noon" : "It's after noon")

如果我们想使用ifand来写出来else，我们要么需要编写这个无效代码：

print(    if hour < 12 {        "It's before noon"    } else {        "It's after noon"    })

或者运行print()两次，如下所示：

if hour < 12 {    print("It's before noon")} else {    print("It's after noon")}

第二个在这里工作得很好，但在 SwiftUI 中几乎不可能，正如你稍后会看到的那样。因此，即使您可能会看到三元运算符并想知道为什么要使用它，请相信我：这很重要！

什么时候应该在 Swift 中使用三元运算符？
三元运算符让我们可以根据条件从两个结果之一中进行选择，并且以一种非常简洁的方式进行：

let isAuthenticated = trueprint(isAuthenticated ? "Welcome!" : "Who are you?")

有些人非常依赖三元运算符，因为它会使代码非常短，而有些人则尽可能远离它，因为它会使代码更难以阅读。

我非常支持“尽可能避免”阵营，因为尽管这段代码较长，但我确实发现它更容易遵循：

if isAuthenticated {    print("Welcome")} else {    print("Who are you?")}

现在，三元运算符有一段时间被大量使用，那就是 SwiftUI。我不想在这里给出代码示例，因为它可能有点让人不知所措，但如果您愿意，您真的可以使用三元运算符进城。即便如此，我还是更愿意在可能的情况下删除它们，以使我的代码更易于阅读，但您应该亲自尝试并得出自己的结论。