switch

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语句来匹配一个名为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") 
} 
// prints "e is a vowel" 

在 Swift 中，当匹配的case块中的代码执行完毕后，程序会终止switch语句，而不会继续执行下一个case块。这也就是说，不需要在case块中显式地使用break语句。这使得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

如果你确实需要C风格的落入(fallthrough)的特性，你可以在每个需要该特性的case分支中使用fallthrough关键字。下面的例子使用fallthrough来创建一个数字的描述语句。

let integerToDescribe = 5 
var description = "The number \(integerToDescribe) is" 
switch integerToDescribe { 
case 2, 3, 5, 7, 11, 13, 17, 19: 
    description += " a prime number, and also" 
    fallthrough 
default: 
    description += " an integer." 
} 
println(description) 
// prints "The number 5 is a prime number, and also an integer." 

NOTE：fallthrough关键字不会检查它下一个将会落入执行的case中的匹配条件。fallthrough简单地使代码执行继续连接到下一个case中的执行代码，这和C语言标准中的switch语句特性是一样的。

范围匹配

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).") 
// prints "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") 
} 
// prints "(1, 1) is inside the box" 

不像C语言，Swift 允许多个case匹配同一个值。实际上，在这个例子中，点(0, 0)可以匹配所有四个case。但是，如果存在多个匹配，那么只会执行第一个被匹配到的case块。考虑点(0, 0)会首先匹配case (0, 0)，因此剩下的能够匹配(0, 0)的case块都会被忽视掉。

值绑定 (Value Bindings)

case块的模式允许将匹配的值绑定到一个临时的常量或变量，这些常量或变量在该case块里就可以被引用了——这种行为被称为值绑定。

下面的例子展示了如何在一个(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))") 
} 
// prints "on the x-axis with an x value of 2" 

这三个case都声明了常量x和y的占位符，用于临时获取元组anotherPoint的一个或两个值。第一个case——case (let x, 0)将匹配一个纵坐标为0的点，并把这个点的横坐标赋给临时的常量x。类似的，第二个case——case (0, let y)将匹配一个横坐标为0的点，并把这个点的纵坐标赋给临时的常量y。

一旦声明了这些临时的常量，它们就可以在其对应的case块里引用。

请注意，这个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") 
} 
// prints "(1, -1) is on the line x == -y" 

Labeled Statements
产生一个带标签的语句是通过在该语句的关键词的同一行前面放置一个标签，并且该标签后面还需带着一个冒号。下面是一个while循环体的语法，同样的规则适用于所有的循环体和switch代码块。

label name: while condition { 
    statements 
} 

如：

gameLoop: while square != finalSquare { 
    if ++diceRoll == 7 { diceRoll = 1 } 
    switch square + diceRoll { 
    case finalSquare: 
        // diceRoll will move us to the final square, so the game is over 
        break gameLoop 
    case let newSquare where newSquare > finalSquare:          // diceRoll will move us beyond the final square, so roll again 
        continue gameLoop 
    default:// this is a valid move, so find out its effect square += diceRoll  square += board[square] } 
} 
println("Game over!") 

break gameLoop语句跳转控制去执行while循环体后的第一行代码，while结束，游戏结束。

continue gameLoop语句结束本次while循环的迭代，开始下一次循环迭代。

NOTE：如果上述的break语句没有使用gameLoop标签，那么它将会中断switch代码块而不是while循环体。使用gameLoop标签清晰的表明了break想要中断的是哪个代码块。