條件語句

根據特定的條件執行特定的代碼通常是十分有用的，例如：當錯誤發生時，你可能想運行額外的代碼；或者，當輸入的值太大或太小時，向用戶顯示一條消息等。要實現這些功能，你就需要使用條件語句。

Swift 提供兩種類型的條件語句：if語句和switch語句。通常，當條件較為簡單且可能的情況很少時，使用if語句。而switch語句更適用於條件較複雜、可能情況較多且需要用到模式匹配(pattern-matching)的情境。

If

if語句最簡單的形式就是隻包含一個條件，當且僅當該條件為true時，才執行相關代碼：

var temperatureInFahrenheit = 30
if temperatureInFahrenheit <= 32 {
    println("It's very cold. Consider wearing a scarf.")
}
// 輸出 "It's very cold. Consider wearing a scarf."

上麵的例子會判斷溫度是否小於等於 32 華氏度(水的冰點)。如果是，則打印一條消息；否則，不打印任何消息，繼續執行if塊後麵的代碼。

當然，if語句允許二選一，也就是當條件為false時，執行 else 語句：

temperatureInFahrenheit = 40
if temperatureInFahrenheit <= 32 {
    println("It's very cold. Consider wearing a scarf.")
} else {
    println("It's not that cold. Wear a t-shirt.")
}
// 輸出 "It's not that cold. Wear a t-shirt."

顯然，這兩條分支中總有一條會被執行。由於溫度已升至 40 華氏度，不算太冷，冇必要再圍圍巾——因此，else分支就被觸發了。

你可以把多個if語句鏈接在一起，像下麵這樣：

temperatureInFahrenheit = 90
if temperatureInFahrenheit <= 32 {
    println("It's very cold. Consider wearing a scarf.")
} else if temperatureInFahrenheit >= 86 {
    println("It's really warm. Don't forget to wear sunscreen.")
} else {
    println("It's not that cold. Wear a t-shirt.")
}
// 輸出 "It's really warm. Don't forget to wear sunscreen."

在上麵的例子中，額外的if語句用於判斷是不是特彆熱。而最後的else語句被保留了下來，用於打印既不冷也不熱時的消息。

實際上，最後的else語句是可選的：

temperatureInFahrenheit = 72
if temperatureInFahrenheit <= 32 {
    println("It's very cold. Consider wearing a scarf.")
} else if temperatureInFahrenheit >= 86 {
    println("It's really warm. Don't forget to wear sunscreen.")
}

在這個例子中，由於既不冷也不熱，所以不會觸發if或else if分支，也就不會打印任何消息。

Switch

switch語句會嘗試把某個值與若乾個模式(pattern)進行匹配。根據第一個匹配成功的模式，switch語句會執行對應的代碼。當有可能的情況較多時，通常用switch語句替換if語句。

switch語句最簡單的形式就是把某個值與一個或若乾個相同類型的值作比較：

switch some value to consider {
case value 1:
respond to value 1
case value 2,
value 3:
respond to value 2 or 3
default:
otherwise, do something else
}

switch語句都由多個 case 構成。為了匹配某些更特定的值，Swift 提供了幾種更複雜的匹配模式，這些模式將在本節的稍後部分提到。

每一個 case 都是代碼執行的一條分支，這與if語句類似。與之不同的是，switch語句會決定哪一條分支應該被執行。

switch語句必須是完備的。這就是說，每一個可能的值都必須至少有一個 case 分支與之對應。在某些不可能涵蓋所有值的情況下，你可以使用默認(default)分支滿足該要求，這個默認分支必須在switch語句的最後麵。

下麵的例子使用switch語句來匹配一個名為someCharacter的小寫字符：

let someCharacter: Character = "e"
switch someCharacter {
case "a", "e", "i", "o", "u":
    println("\(someCharacter) is a vowel")
case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
"n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
    println("\(someCharacter) is a consonant")
default:
    println("\(someCharacter) is not a vowel or a consonant")
}
// 輸出 "e is a vowel"

在這個例子中，第一個 case 分支用於匹配五個元音，第二個 case 分支用於匹配所有的輔音。

由於為其它可能的字符寫 case 分支冇有實際的意義，因此在這個例子中使用了默認分支來處理剩下的既不是元音也不是輔音的字符——這就保證了switch語句的完備性。

不存在隱式的貫穿(No Implicit Fallthrough)

與 C 語言和 Objective-C 中的switch語句不同，在 Swift 中，當匹配的 case 分支中的代碼執行完畢後，程序會終止switch語句，而不會繼續執行下一個 case 分支。這也就是說，不需要在 case 分支中顯式地使用break語句。這使得switch語句更安全、更易用，也避免了因忘記寫break語句而產生的錯誤。

注意：
你依然可以在 case 分支中的代碼執行完畢前跳出，詳情請參考Switch 語句中的 break。
 

每一個 case 分支都必須包含至少一條語句。像下麵這樣書寫代碼是無效的，因為第一個 case 分支是空的：

let anotherCharacter: Character = "a"
switch anotherCharacter {
case "a":
case "A":
    println("The letter A")
default:
    println("Not the letter A")
}
// this will report a compile-time error

不像 C 語言裡的switch語句，在 Swift 中，switch語句不會同時匹配"a"和"A"。相反的，上麵的代碼會引起編譯期錯誤：case "a": does not contain any executable statements——這就避免了意外地從一個 case 分支貫穿到另外一個，使得代碼更安全、也更直觀。

一個 case 也可以包含多個模式，用逗號把它們分開(如果太長了也可以分行寫)：

switch some value to consider {
case value 1,
value 2:
statements
}

注意：
如果想要貫穿至特定的 case 分支中，請使用fallthrough語句，詳情請參考貫穿(Fallthrough)。
 

區間匹配(Range Matching)

case 分支的模式也可以是一個值的區間。下麵的例子展示了如何使用區間匹配來輸出任意數字對應的自然語言格式：

let count = 3_000_000_000_000
let countedThings = "stars in the Milky Way"
var naturalCount: String
switch count {
case 0:
    naturalCount = "no"
case 1...3:
    naturalCount = "a few"
case 4...9:
    naturalCount = "several"
case 10...99:
    naturalCount = "tens of"
case 100...999:
    naturalCount = "hundreds of"
case 1000...999_999:
    naturalCount = "thousands of"
default:
    naturalCount = "millions and millions of"
}
println("There are \(naturalCount) \(countedThings).")
// 輸出 "There are millions and millions of stars in the Milky Way."

元組(Tuple)

你可以使用元組在同一個switch語句中測試多個值。元組中的元素可以是值，也可以是區間。另外，使用下劃線(_)來匹配所有可能的值。

下麵的例子展示了如何使用一個(Int, Int)類型的元組來分類下圖中的點(x, y)：

let somePoint = (1, 1)
switch somePoint {
case (0, 0):
    println("(0, 0) is at the origin")
case (_, 0):
    println("(\(somePoint.0), 0) is on the x-axis")
case (0, _):
    println("(0, \(somePoint.1)) is on the y-axis")
case (-2...2, -2...2):
    println("(\(somePoint.0), \(somePoint.1)) is inside the box")
default:
    println("(\(somePoint.0), \(somePoint.1)) is outside of the box")
}
// 輸出 "(1, 1) is inside the box"

在上麵的例子中，switch語句會判斷某個點是否是原點(0, 0)，是否在紅色的x軸上，是否在黃色y軸上，是否在一個以原點為中心的4x4的矩形裡，或者在這個矩形外麵。

不像 C 語言，Swift 允許多個 case 匹配同一個值。實際上，在這個例子中，點(0, 0)可以匹配所有四個 case。但是，如果存在多個匹配，那麼隻會執行第一個被匹配到的 case 分支。考慮點(0, 0)會首先匹配case (0, 0)，因此剩下的能夠匹配(0, 0)的 case 分支都會被忽視掉。

值綁定(Value Bindings)

case 分支的模式允許將匹配的值綁定到一個臨時的常量或變量，這些常量或變量在該 case 分支裡就可以被引用了——這種行為被稱為值綁定(value binding)。

下麵的例子展示了如何在一個(Int, Int)類型的元組中使用值綁定來分類下圖中的點(x, y)：

let anotherPoint = (2, 0)
switch anotherPoint {
case (let x, 0):
    println("on the x-axis with an x value of \(x)")
case (0, let y):
    println("on the y-axis with a y value of \(y)")
case let (x, y):
    println("somewhere else at (\(x), \(y))")
}
// 輸出 "on the x-axis with an x value of 2"

在上麵的例子中，switch語句會判斷某個點是否在紅色的x軸上，是否在黃色y軸上，或者不在坐標軸上。

這三個 case 都聲明了常量x和y的占位符，用於臨時獲取元組anotherPoint的一個或兩個值。第一個 case ——case (let x, 0)將匹配一個縱坐標為0的點，並把這個點的橫坐標賦給臨時的常量x。類似的，第二個 case ——case (0, let y)將匹配一個橫坐標為0的點，並把這個點的縱坐標賦給臨時的常量y。

一旦聲明了這些臨時的常量，它們就可以在其對應的 case 分支裡引用。在這個例子中，它們用於簡化println的書寫。

請注意，這個switch語句不包含默認分支。這是因為最後一個 case ——case let(x, y)聲明了一個可以匹配餘下所有值的元組。這使得switch語句已經完備了，因此不需要再書寫默認分支。

在上麵的例子中，x和y是常量，這是因為冇有必要在其對應的 case 分支中修改它們的值。然而，它們也可以是變量——程序將會創建臨時變量，並用相應的值初始化它。修改這些變量隻會影響其對應的 case 分支。

Where

case 分支的模式可以使用where語句來判斷額外的條件。

下麵的例子把下圖中的點(x, y)進行了分類：

let yetAnotherPoint = (1, -1)
switch yetAnotherPoint {
case let (x, y) where x == y:
    println("(\(x), \(y)) is on the line x == y")
case let (x, y) where x == -y:
    println("(\(x), \(y)) is on the line x == -y")
case let (x, y):
    println("(\(x), \(y)) is just some arbitrary point")
}
// 輸出 "(1, -1) is on the line x == -y"

在上麵的例子中，switch語句會判斷某個點是否在綠色的對角線x == y上，是否在紫色的對角線x == -y上，或者不在對角線上。

這三個 case 都聲明了常量x和y的占位符，用於臨時獲取元組yetAnotherPoint的兩個值。這些常量被用作where語句的一部分，從而創建一個動態的過濾器(filter)。當且僅當where語句的條件為true時，匹配到的 case 分支才會被執行。

就像是值綁定中的例子，由於最後一個 case 分支匹配了餘下所有可能的值，switch語句就已經完備了，因此不需要再書寫默認分支。