Swift流程掌握之輪回語句和斷定語句詳解。本站提示廣大學習愛好者：（Swift流程掌握之輪回語句和斷定語句詳解）文章只能為提供參考，不一定能成為您想要的結果。以下是Swift流程掌握之輪回語句和斷定語句詳解正文
Swift供給了一切c類說話的掌握流構造。包含for和while輪回來履行一個義務屢次；if和switch語句來履行肯定的前提下分歧的分支的代碼；break和continue症結字能將運轉流程轉到你代碼的另外一個點上。
除C說話傳統的for-condition-increment輪回，Swift參加了for-in輪回，能加倍輕易的遍歷arrays, dictionaries, ranges, strings等其他序列類型。
Swift的switch語句也比C說話的要壯大許多。 Swift中switch語句的case語句不會“失落入”下一個case，防止了c說話忘卻寫break語句發生的毛病。 case可以婚配很多分歧的形式，包含規模婚配，元組婚配或許拋給指定的類型。婚配值在一個case前提下可以綁定莅臨經常量或變量，可以在case的代碼塊中應用，龐雜婚配前提下可以表現為每個case的前提
1、For Loops - For輪回
for輪回用來屢次履行一組語句 ，Swift供給了兩種情勢：
1.for-in履行規模，序列，聚集或級數等每項中的一組語句
2.for-condition-increment履行一組語句直到肯定的前提湧現，平日在每個輪回停止前遞增一個計數
For-In輪回
應用for-in來遍歷聚集中的項目，好比數組的規模，分列中的項或許字符串中的字符。
上面的例子打印了表中的5個元素
for index in 1...5 {
println("\(index) times 5 is \(index * 5)")
}
// 1 times 5 is 5
// 2 times 5 is 10
// 3 times 5 is 15
// 4 times 5 is 20
// 5 times 5 is 25
例子中被迭代聚集的項是一個關閉規模內從1到5的數字，就是下面標識為關閉規模操作符的 (...)。 Index的值被設為第一個數據的規模(1), 然後履行輪回中的語句。在本例中，輪回只包括了一句話，依據index現有的值打印5次乘法表的一個成果。當履行完語句以後，index的值被更新為規模中的第二個值,然後再次挪用println函數。這個操作會一向連續，直到規模的起點。
在下面的例子中，index是一個常量，它的值在每次迭代的開端時主動初始化，應用前不會被聲明，就是簡略的將其隱性聲明歸入輪回的聲明，不須要應用let來聲明症結字。
NOTE：
Index常量僅僅存在於輪回的規模內。假如你想要在輪回以後獲得index的值，或許想要應用index的值作為變量，你必需在輪回之前聲明它。
假如不須要規模的值，可以用下劃線替換變量名來疏忽這些值:
let base = 3
let power = 10
var answer = 1
for _ in 1...power {
answer *= base
}
println("\(base) to the power of \(power) is \(answer)")
// prints "3 to the power of 10 is 59049"
例子上鉤算兩數相乘（在本例中，3乘以10）。乘法初始值為1，每次乘3，乘10次，應用半關閉輪回從0到9。這個盤算不須要經由過程輪回來曉得每一個計數器的值--僅僅只須要履行准確的輪回次數。下劃線操作符 _ (用於替換輪回變量)將疏忽失落個別值，而且在每次輪回迭代時代不給現有的變量供給拜訪。
應用for-in輪回來迭代出array中的每個項：
let names = ["Anna", "Alex", "Brian", "Jack"]
for name in names {
println("Hello, \(name)!")
}
// Hello, Anna!
// Hello, Alex!
// Hello, Brian!
// Hello, Jack!
異樣可以迭代字典來拜訪個中的鍵值對。當迭代字典時外面的每個項都以（key,value）元組的情勢來前往，你可以在for-in的輪回體平分解 (key, value) 元組的成員，把成員作為顯生命名的常量來應用。上面例子，字典的key被分化為animalName的常量，字典的值被分化名為legCount的常量：
let numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
for (animalName, legCount) in numberOfLegs {
println("\(animalName)s have \(legCount) legs")
}
// spiders have 8 legs
// ants have 6 legs
// cats have 4 legs
Dictionary中的項的迭代次序能夠跟它們拔出時的次序紛歧樣。由於Dictionary中的內容實質上是無序的，所以迭代它們不克不及包管檢索時的次序。更多關於分列和字典的內容詳見 Collection Types章節。
除分列和字典，for-in輪回還能迭代字符串中的Character（字符）：
for character in "Hello" {
println(character)
}
// H
// e
// l
// l
// o
For-Condition-Increment For-前提-遞增
除for-in輪回，Swift還支撐傳統C說話按前提遞增的for輪回
for var index = 0; index < 3; ++index {
println("index is \(index)")
}
// index is 0
// index is 1
// index is 2
這是經常使用的情勢：
for <initialization>; <condition>; <increment> {
<statements>
}
封號把輪回界說隔為了三個部門，跟C說話一樣。但是與C分歧的是，Swift不須要用括號把 “初始化; 前提; 增量” 的代碼塊包起來。
輪回依照上面流程履行：
1.當輪回第一次進入，initialization expression（初始化表達式）盤算一次，設置好輪回所需的常量或許變量。
2.盤算condition expression（前提表達式）。假如盤算成果為false（假），輪回終止，並持續履行for輪回尾括號（}）前面的代碼。假如成果為（true）真，則履行輪回體年夜括號內的代碼。
3.在一切的語句履行完後，盤算increment expression(增量表達式)。計數器能夠遞增或遞加，也能夠依據語句履行的成果將初始化變量設為新的值。盤算完增量表達式前往到第2步，前提表達式再次被盤算。
下面描寫的輪回體的情勢和履行進程可以簡略的同等於：
<initialization>
while <condition> {
<statements>
<increment>
}
常量和變量在初始化表達式中的聲明（好比var index = 0）只在for輪回本身外部有用。假如須要曉得index終究的值，必需在輪回開端前聲明index：
var index: Int
for index = 0; index < 3; ++index {
println("index is \(index)")
}
// index is 0
// index is 1
// index is 2
println("The loop statements were executed \(index) times")
// prints "The loop statements were executed 3 times"
留意，輪回完成後index終究的值是3，不是2。最初一次履行增量表達式挪用了++index，把index設為3，使得index<3等於false，輪回停止。
2、While Loops - While輪回
while輪回在前提變成false前履行一組語句，這類輪回最好用在第一個迭代開端前其實不曉得迭代器的數字的時刻。Swift供給了兩種while輪回:
1.while 在每次經由過程輪回的開首盤算前提
2.do-while 在每次經由過程輪回的開頭盤算前提
while輪回
一個while輪回開端於盤算單個的前提，假如前提為true，一組語句將反復直到前提變成false。
這是罕見的while情勢：
while <condition> {
<statements>
}
好比，玩這個叫Snakes and Ladders的游戲（或Chutes and Ladders）:
游戲的規矩是如許的：
1.板子上有25個矩形，然後目的是達到或超出25號方塊。
2.每輪，你先搖六面骰子，然後依照程度偏向的虛線箭頭挪動到對應數字的方塊上。
3.假如走完落在梯子的底部，你可以爬上梯子。
4.假如走完落在蛇的頭部，你可以走到那條蛇的尾部。
這個游戲板由一個Int型數組展現出來。它的年夜小基於finalSquare常量，該常量用來初始化數組並在以後檢討成功前提。游戲板初始化為26個值為0的Int型數據，不是25個（分離位於0至25的索引）：
let finalSquare = 25
var board = Int
一些方塊給蛇與梯子設有詳細的值。游戲板裡，你能在無方塊有梯子腳的處所向上挪動負數，而有蛇頭的處所你只能向下挪動正數：
board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
方塊3有梯子腳，所以你可以挪動到方塊11。為了表述這個舉措，board[03]等於+08,同等於一個整型數值8（即3和11的差）。一元運算符加運算符（+i）與一元減運算符（-i）相均衡，假如數值小於10就用0替換，如許所板上的界說就對齊了。(作風調劑不是必需的，但代碼簡練很有需要)
玩家開端於方塊0，就在游戲板左下角的裡面。第一下投骰是把玩家帶到游戲版外面：
var square = 0
var diceRoll = 0
while square < finalSquare {
// roll the dice
if ++diceRoll == 7 { diceRoll = 1 }
// move by the rolled amount
square += diceRoll
if square < board.count {
// if we're still on the board, move up or down for a snake or a ladder
square += board[square]
}
}
println("Game over!")
這個例子很簡略的模仿了投骰子。用隨機數的生成器來替換，diceRoll從0開端。每個while輪回，diceRoll經由過程自加運算符（++i）遞增，然後檢討能否過年夜。++diceRoll的前往值等於diceRoll自加今後的值。假如前往值等於7，骰子值則過年夜，重設為1。如許diceRoll的值會一向是1，2，3，4，5，6，1，2等等。
在搖骰子後，玩家依據diceRoll挪動方塊。有能夠骰子的數會讓玩家跨越方塊25，如許就算游戲停止。為了描寫這個場景，代碼在向board[square]添加值之前先檢討square的值能否少於board數組的count屬性，假如是則依據現有的square值將玩家上移或下移到響應梯子或蛇。
假如不履行這個檢討，board[square]會能夠測驗考試獲得board數組界線外的值，招致越界。假如square如今等於26，代碼將測驗考試檢討board[26]，這個值跨越了數組限制。
現有的While輪回履行到最初，會檢討輪回前提看輪回能否會再次履行。假如玩家曾經挪動或許方塊跨越25，輪回前提管帳算為false，游戲停止。
在這個例子中應用While輪回是比擬適合的，由於游戲的長度在輪回的開首不明白，讓輪回一向履行直到特定的知足前提湧現。
Do-While輪回
While輪回的另外一個情勢是do-while，在斟酌輪回前提前先履行一次全部輪回體，然後再持續反復輪回直到前提為false。
上面是do-while的罕見情勢:
do {
<statements>
} while <condition>
再來看看Snakes and Ladders的例子，用do-while而不是while來完成。finalSquare, board, square, 和diceRoll都用雷同的方法初始化：
let finalSquare = 25
var board = Int[](count: finalSquare + 1, repeatedValue: 0)
board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
var square = 0
var diceRoll = 0
在這個版本的游戲中，輪回中第一個操作是檢討一個梯子或蛇。沒有梯子能直接把玩家帶到方塊25，所以弗成能只爬一個梯子就贏了。是以在輪回裡先檢討梯子或蛇會更平安。
游戲的開端，玩家在“方塊0”。 board[0]永久等於0，沒有其余功效：
do {
// move up or down for a snake or ladder
square += board[square]
// roll the dice
if ++diceRoll == 7 { diceRoll = 1 }
// move by the rolled amount
square += diceRoll
} while square < finalSquare
println("Game over!")
在代碼檢討後，開端搖骰子，玩家經由過程diceRoll方塊向前挪動，該循一向環履行到最初。
輪回前提(while square < finalSquare)跟之前例子一樣，然則此次會在第一次輪回的開頭才盤算。do-while輪回的構造比while輪回更合適本例。下面do-while中，在輪回前提確認square仍然在游戲板外面後，square += board[square]會直接停止盤算，不用停止數組越界的檢討。
3、Conditional Statements - 前提語句
編程中經常依據分歧的前提履行分歧的代碼，你能夠會要代碼在失足後運轉額定的語句，或許當數值越界時展現一個新聞。我們可以用conditional（前提）來完成。
Swift供給兩種方法來添加代碼的分支，罕見的if和switch語句。明顯，用if語句來盤算只要大批分支的的前提，而Switch用於更龐雜的情形，特殊是在形式婚配的時刻有助於選擇適合的代碼分支來履行。
If語句
鄙人面最簡略的例子裡，if語句有一個if前提。一切的語句都只要在if前提為true的情形下才履行：
var temperatureInFahrenheit = 30
if temperatureInFahrenheit <= 32 {
println("It's very cold. Consider wearing a scarf.")
}
// prints "It's very cold. Consider wearing a scarf."
後面的例子檢討了溫度能否等於32攝氏度。假如是則打印新聞。不然不打印新聞，直接履行if語句年夜括號前面的代碼。
if語句可以供給一個二選一的語句，罕見的：else clause，用於當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.")
}
// prints "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.")
}
// prints "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前提來打印信息。
Switch語句
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（情形）組成，都用標志的case症結字開首。除比擬對應的值，Swift還為每種case應對更龐雜的婚配形式供給了幾種辦法，前面章節再說。
每個switch語句都必需exhaustive（具體），而且每個所斟酌類選能夠的值都必需婚配switch中的一個case。假如不克不及對應到switch中的一切case的值，可以界說個默許的拔取器來處理。拔取器用default症結字來表現，必需湧現在最初。
上面的例子用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"
Switch語句第一個case婚配了5個小寫的元音字母。類似地，第二個case婚配一切的子音小寫字母。
case中其實不須要寫上一切其他的英語字母，所以switch供給了default來婚配其他一切不是元音也不是子音的情形。如許的前提包管了switch沒有漏掉。
No Implicit Fallthrough - 沒有隱性失落入
比擬C和objective-c中的switch語句，Swift中（假如忘了寫break）的switch不會默許的失落落到每一個case的上面進入另外一個case。相反，switch語句當第一個碰到的case完成時就完成了它全部的履行，不須要寫break。是以比起C說話，swift的switch加倍平安和簡略，防止了履行多個case的毛病。
NOTE：
假如你須要，仍然可在case履行完之前跳出來，詳見：[Break in a Switch Statement]見上面章節
每一個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，這裡的switch語句不克不及婚配"a"和"A"。好比，case "a"會在編譯時報錯：沒有找就任何可履行語句。盡量的防止了不測從一個case失落入另外一個，如許使代碼更平安。
假如有多個婚配對象的，可以用逗號離隔，像上面如許寫成多行：
switch some value to consider {
case value 1,
value 2:
statements
}
NOTE：
為特殊的switch case選擇失落落行動，可使用fallthrough症結字，鄙人文中詳解
Range Matching - 規模婚配
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."
Tuples 元組
你可使用元組在雷同的switch語句中測試多個值。每個元組中的元素都可以試著和規模中分歧的值停止婚配。別的，用下劃線（_）標示符來婚配隨意率性能夠的值。
上面例子中應用一個點坐標（x,y），用元組型(Int, Int)來表現，可以鄙人面的圖平分類出來：
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"
Switch語句決議了點能否在原點（0，0）上，在白色的x軸上，在橙色的y軸上，在藍色4X4的矩形為中間的原點內，或許在矩形外。
與C說話分歧，Swift許可多個switch的case斟酌雷同的值。現實上點(0,0)能婚配例子中一切的四個case。但是，假如多個婚配湧現，第一個婚配勝利的case將被應用。點（0，0）能起首婚配case（0，0），所以其他一切的case將被疏忽。
Value Bindings 值綁定
一個switch的case能綁定用於婚配暫時常量或變量值，在case的分支代碼裡應用。這就是value binding（值綁定），由於這些值在case的代碼體中是暫時常量或變量的“界限”。
上面的例子有一個點（x,y），用元組型(Int,Int)來表現，在圖種展現出來以下:
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
switch語句來肯定點能否在白色x軸上，在橙色y軸，或許其他處所。
三個switch的case都聲清楚明了占位常量x和y，臨時從anotherPoint占用一個或兩個元組值。第一個case裡，case (let x, 0)，婚配給隨意率性一個y值為0，並分配點的x值給暫時常量x的點。類似地，第二個case，case (0, let y)，婚配給一個x值為0，分配點的y值給暫時常量y的點。
一旦暫時常量被聲明，他們將在case的代碼塊中應用。這裡他們將作為簡寫在println函數中打印出來。
留意switch語句沒有default的case。最初一個case，case let (x, y)，聲清楚明了包括兩個占位常量可以婚配任何值的元組。作為成果，它婚配任何能夠的值，不須要default語句switch就足夠完善了。
下面的例子中，聲明x和y用了症結詞let，由於這裡不須要在case的代碼段裡轉變它們的值。但是，他們可以用變量來取代，應用var症結詞。假如用了變量，則會創立暫時變量並初始化為適合的值。任何對變量的轉變都只會影響case代碼段中的部門。
Where語句
switch的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"
switch語句斷定了點能否在綠色斜線上且x == y，或在紫色斜線上且x == -y，或都不是。
三個switch的case聲清楚明了占位常量x和y，暫時占用point中元組值。這些常量作為where子句的一部門，用來創立靜態的挑選。只要當where子句的前提成果為true，Switch的case則會婚配現有point的值。
就像在前一個例子中，最初的case婚配一切能夠的值，所以不須要default。
Control Transfer Statements - 掌握轉移語句
掌握轉移語句能轉變曾經履行代碼的次序，能使代碼跳轉到其余部門。Swift有四個句子：
1.continue
2.break
3.fallthrough
4.return
control, break和fallthrough鄙人文中詳解。reture語句在Functions中描寫。
Continue
Continue語句告知輪回體終止如今的操作，然後開端迭代下一個輪回。似乎在說“我此次迭代做完啦”，總之不會分開輪回體。
NOTE：
在for-condition-increment輪回中，挪用了continue後累加器照舊管帳算。輪回會持續像日常平凡一樣任務，只要輪回體中的代碼會被跳過。
上面例子中從一個小寫字符串中移除一切的元音和空格，創立了個燈謎短語：
let puzzleInput = "great minds think alike"
var puzzleOutput = ""
for character in puzzleInput {
switch character {
case "a", "e", "i", "o", "u", " ":
continue
default:
puzzleOutput += character
}
}
println(puzzleOutput)
// prints "grtmndsthnklk"
下面代碼裡，只需婚配到元音字母或空格，就會觸發continue症結字。使本次迭代立刻終止，然後直接跳入下次迭代的開首。這個方法使得switch代碼塊能婚配(和疏忽)元音字母與空格，比用代碼塊把每個要打印字符都婚配一次的好。
Break
Break語句能立刻終止全部掌握流。可以依據你想要的在switch或輪回語句裡的任何處所終止全部履行。
Break in a Loop Statement - 輪回中的Break
當在輪回體中應用break，輪回會立刻停滯，並將掌握流帶到輪回體括號(})前方的第一行代碼裡。輪回體裡其他的代碼不會被履行，也不會開端下一次迭代。
Break in a Switch Statement - Switch中的break
在switch裡應用break，switch語句會立刻終止，並將掌握流帶到switch語句括號(})前方的第一行代碼裡。
這類特征可以用於switch裡婚配（或疏忽）一個或多個case。由於Swift的switch是窮舉的，而且不許可有空case的，有時刻要鄭重的婚配和為了使意圖顯著而疏忽了case。當switch婚配了break語句，case中的break能直接終止全部switch。
NOTE：
一個switch的case只能包括一個作為編譯毛病的正文。正文不是語句，不會招致switch的case被疏忽。只能應用break語句來跳過case。
上面的例子中switch有一個字符值，而且斷定四種說話之一中能否稀有字符號。一個簡略的switch中包括了多個值：
let numberSymbol: Character = "三" // Simplified Chinese for the number 3
var possibleIntegerValue: Int?
switch numberSymbol {
case "1", "١", "一", "๑":
possibleIntegerValue = 1
case "2", "٢", "二", "๒":
possibleIntegerValue = 2
case "3", "٣", "三", "๓":
possibleIntegerValue = 3
case "4", "٤", "四", "๔":
possibleIntegerValue = 4
default:
break
}
if let integerValue = possibleIntegerValue {
println("The integer value of \(numberSymbol) is \(integerValue).")
} else {
println("An integer value could not be found for \(numberSymbol).")
}
// prints "The integer value of 三 is 3."
例子中經由過程檢討numberSymbol斷定能否是拉丁語，阿拉伯語，中文或許泰文符號來獲得1至4的數字。假如婚配勝利，個中的一個case裡會賦給可選型Int變量possibleIntegerValue一個適合的整型值。
在switch語句履行完成後，例子裡用了可選型綁定來肯定值能否被發明。possibleIntegerValue變量有一個隱性的初始值nil，具有可選型的長處。只要在前四個case中，當possibleIntegerValue被賦了現實的值可選綁定才會勝利。
在下面例子中列出一切能夠的字符值不太現實，所以default能供給一個沒任何字符被選中情形下的容器。這的default不消履行任何操作，只寫個簡略的break。一旦default被婚配，break語句立刻終止switch，並持續履行 if let語句。
Fallthrough
Swift中的Switch不會失落下到case的下方並進入下一個case。是以，全部switch語句毀在第一個婚配的case完成後停止。相反，C說話請求你在每一個case的末尾拔出一個break來避免失落入。比擬於C說話，Swift的switch制止默許失落入讓加倍簡練和可控，如許防止了履行多個case的毛病。
假如你確切須要C式的失落入特征，你可使用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."
例子中聲清楚明了一個名為description的String型變量並分配一個初始值。然後函數用switch婚配integerToDescribe的值。假如integerToDescribe的值相符素數列表中的一項，最初的description會增長一段字符，留意數字都是素數。然後用fallthrough症結字讓代碼“失落到”default裡。default的代碼中再額定的給字符串添加些描寫，最初switch停止。
假如integerToDescribe不跟素數表中任何一項婚配，那基本就不會婚配switch的第一個case。這外面沒有其他的case，是以integerToDescribe直接進入default容器。
在switch履行完成後，數字的描寫用println函數打印出來。在本例中，5是准確的謎底。
NOTE：
fallthrough症結字不檢討case裡的前提，會直接失落入下一個case。fallthrough簡略的讓代碼履行到下一個case（或default）的代碼塊中，和尺度C說話的特征一樣。
Labeled Statements - 標簽語句
你可以嵌套輪回或在switch語句中嵌套其他的輪回，Swift語句種的switch可以創立龐雜的掌握流構造。 但是，輪回和switch語句都可以過早地應用break。是以，有時明白的應用break來終止代碼很有效。相似的，假如你有多個嵌套的輪回，continue會更有效。
為了做到這一點，你可以用statement label來標志輪回或switch，與break或continue語句一路應用這個標簽來終止或持續標志語句的履行。
標簽語句作為引誘症結詞在標簽的統一行，前面隨著冒號“：”。 這裡有一個用了該符號的while輪回例子，一切的輪回和switch都是雷同的。
<label name>: while <condition> {
<statements>
}
上面的例子裡有一個用了標簽的while輪回，應用了break和continue語句，Snakes and Ladders游戲可以在上文中看到：
為了成功，你必需正好達到25號方塊
假如骰子帶你跨越了25號方塊，你必需從新丟骰子直到正好抵達25號方塊。
游戲板和上文中的一樣
變量 finalSquare, board, square, diceRoll的初始化都跟前文一樣：
let finalSquare = 25
var board = Int[](count: finalSquare + 1, repeatedValue: 0)
board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
var square = 0
var diceRoll = 0
這個版本用while輪回和switch語句來完成游戲邏輯。While輪回的標簽為gameLoop，為Snakes and Ladders Game標志出游戲主體。
While輪回的前提是while square != finalSquare，意思是你必需落在25號方塊上：
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!")
骰子在每一個輪回的最開端動搖。然後玩家立刻挪動，switch語句用來斷定挪動的成果，算出能否許可挪動：
假如骰子帶玩家抵達最初的方塊，游戲停止。break gameLoop語句將掌握流帶到游戲停止的處所，即while輪回外的第一行。
假如骰子跨越了最初的方塊，則挪動有效，玩家須要再次投骰。break gameLoop會終止本次迭代，開端下次迭代。
在其他的情形下，骰子有用。玩家向前挪動方塊並依據游戲邏輯檢討蛇或梯子。輪回停止，掌握流前往到while前提斷定處，決議能否須要再次迭代。
NOTE 假如下面的break語句不應用gameLoop標簽，將會中止switch語句，而不是while語句。應用gameLoop標簽可以加倍明白的讓掌握流終止。
異樣要留意，當挪用continue gameLoop來跳到下一個迭代輪回中不是必需應用gameLoop標簽。由於這裡只要一個輪回體，不會遭到其他輪回體的影響。但是，用了gameLoop標簽也沒甚麼欠好。如許做堅持與break旁邊的標簽同一，有助於讓游戲邏輯能加倍清楚浏覽和懂得。
