之前學習swift時的個人筆記，根據(jù)github：the-swift-programming-language-in-chinese學習、總結(jié)，將重要的內(nèi)容提取，加以理解后整理為學習筆記，方便以后查詢用。詳細可以參考the-swift-programming-language-in-chinese，或者蘋果官方英文版文檔

當前版本是swift2.2

包含內(nèi)容：

1. print函數(shù)

• weak與unowned
• 注釋
• 類型轉(zhuǎn)換
• 類型別名
• 元組
• 可選類型
• 使用斷言進行調(diào)試
• 運算符
• 字符串
• Arrays、Sets和Dictionaries三種集合
• 數(shù)組(Arrays)
• 集合（Sets）
• 字典
• 控制流
• For-In 循環(huán)
• 標簽語句
• 檢測 API 可用性

print函數(shù)

函數(shù)原型
print(items, separator: String, terminator: String)

參數(shù)：

• items：要打印的變量，或常量
• separator：多個item參數(shù)之間的間隔符
• terminator：打印的末尾可以增加一個字符串

weak與unowned

在OC中，當__weak指向的對象被釋放時，weak指向nil，在swift中也一樣，那么weak修飾的變量應該為可選類型。
unowned相當于oc中的_unsafe_unretained,對象釋放后后指向一塊固定的內(nèi)存。

• weak用在：當self對象優(yōu)先于block調(diào)用時
• unowned：當self對象在block調(diào)用時不會被釋放

swift中提供了捕獲列表更優(yōu)雅的解決了這個問題

注釋

支持 // 注釋和塊注釋/**/，還支持注釋嵌套(C語言不支持)：

/* 這是第一個多行注釋的開頭
    /* 這是第二個被嵌套的多行注釋 */
這是第一個多行注釋的結(jié)尾 */

類型轉(zhuǎn)換

一百萬可以兩種表示：1000000或1_000_000

let value = 3 + 0.14159 // value最終類型為Double類型，原始值3沒有顯式聲明類型，0.14159默認為Double類型

而下面的例子，則不可以：

let three = 3
let pointOneFourOneFiveNine = 0.14159
let pi = three + pointOneFourOneFiveNine // 錯誤

let integerPi = Int(pi)
// integerPi 等于 3，所以被推測為 Int 類型。浮點值會被截斷。也就是說4.75會變成4，-3.9會變成-3。

不同類型變量不支持隱式轉(zhuǎn)換.在下面的例子中，常量twoThousand是UInt16類型，然而常量one是UInt8類型。它們不能直接相加，因為它們類型不同。所以要調(diào)用UInt16(one)來創(chuàng)建一個新的UInt16數(shù)字并用one的值來初始化，然后使用這個新數(shù)字來計算：

let twoThousand: UInt16 = 2_000
let one: UInt8 = 1
let twoThousandAndOne = twoThousand + UInt16(one)
現(xiàn)在兩個數(shù)字的類型都是UInt16，可以進行相加。目標常量twoThousandAndOne的類型被推斷為UInt16，因為它是兩個UInt16值的和。

UInt16(one)是調(diào)用 Swift 構(gòu)造器并傳入一個初始值的默認方法。在語言內(nèi)部，UInt16有一個構(gòu)造器，可以接受一個UInt8類型的值，所以這個構(gòu)造器可以用現(xiàn)有的UInt8來創(chuàng)建一個新的UInt16。注意，你并不能傳入任意類型的值，只能傳入UInt16內(nèi)部有對應構(gòu)造器的值。不過你可以擴展現(xiàn)有的類型來讓它可以接收其他類型的值

float和double類型也不能直接相加

類型別名

typealias AudioSample = UInt16

定義了一個類型別名之后，你可以在任何使用原始名的地方使用別名：

var maxAmplitudeFound = AudioSample.min // 值為0

元組

把多個值組合成一個復合值。元組內(nèi)的值可以是任意類型，并不要求是相同類型。

你可以將一個元組的內(nèi)容分解（decompose）成單獨的常量和變量，然后你就可以正常使用它們了：

let http404Error = (404, "Not Found")  
let (statusCode, statusMessage) = http404Error
print("The status code is \(statusCode)") // 輸出 "The status code is 404"
print("The status message is \(statusMessage)") // 輸出 "The status message is Not Found"

如果你只需要一部分元組值，分解的時候可以把要忽略的部分用下劃線（_）標記：

let (justTheStatusCode, _) = http404Error
print("The status code is \(justTheStatusCode)") // 輸出 "The status code is 404"

此外，你還可以通過下標來訪問元組中的單個元素，下標從零開始：

print("The status code is \(http404Error.0)") // 輸出 "The status code is 404"
print("The status message is \(http404Error.1)") // 輸出 "The status message is Not Found"

你可以在定義元組的時候給單個元素命名：

let http200Status = (statusCode: 200, description: "OK")

給元組中的元素命名后，你可以通過名字來獲取這些元素的值：

print("The status code is \(http200Status.statusCode)") // 輸出 "The status code is 200"
print("The status message is \(http200Status.description)") // 輸出 "The status message is OK"

元組在臨時組織值的時候很有用，但是并不適合創(chuàng)建復雜的數(shù)據(jù)結(jié)構(gòu)。如果你的數(shù)據(jù)結(jié)構(gòu)并不是臨時使用，請使用類或者結(jié)構(gòu)體而不是元組。請參考類和結(jié)構(gòu)體。

可選類型

可選類型不能像普通類型一樣使用，比如兩個可選類型相加會報錯，不只相加，加減乘除等等
如果你聲明一個可選常量或者變量但是沒有賦值，它們會自動被設(shè)置為nil：

var surveyAnswer: String? // surveyAnswer 被自動設(shè)置為 nil

一個變量或常量被定義為可選類型，那么它就不是原來的類型了，而是可選類型，只有解析后為有值才可以回到原來的類型。

let inta:Int? = 3
let intb:Int! = 4
print(inta + intb)  // 錯誤，正確應該是inta! + intb
if inta != nil {
    print(inta + intb)  // 錯誤，正確應該是inta! + intb
}

if let intc = inta {    
    print(intc + intb)  // 可選綁定可以當非可選類型使用
}

隱式解析可選類型

一個可選類型總會有值，這種類型的可選狀態(tài)被定義為隱式解析可選類型
比如例子中的intb被定義為"隱式解析可選類型"，它還是可選類型，可以賦值為nil，也可以可選綁定。
在使用隱式解析可選類型時，不用加！,系統(tǒng)會自動解析，就從可選類型變?yōu)樗旧淼念愋停梢园央[式解析可選類型當做一個可以自動解析的可選類型

var intb:Int! = 4 // 隱式解析可選類型
intb = nil  // 賦值為nil
if let intc = intb { // 可選綁定
    print(intc + intb)
}

強制解析

當你確定可選類型確實包含值之后，你可以在可選的名字后面加一個感嘆號（!）來獲取值，這被稱為可選值的強制解析。強制解析一定要確保有值，否則會程序崩潰。

nil

在oc中代表一個空指針（指向不存在對象的指針）。僅僅限于對象
在swift中代表一個可選值的狀態(tài)為沒有值，它是一個確定的值，用來表示值缺失，不僅限于對象

可選綁定

使用可選綁定（optional binding）來判斷可選類型是否包含值，如果包含就把值賦給一個臨時常量或者變量?？蛇x綁定可以用在if和while語句中，這條語句不僅可以用來判斷可選類型中是否有值，同時可以將可選類型中的值賦給一個常量或者變量，賦給的常量或者變量的作用域只是在if緊跟的大括號內(nèi)，賦值失敗，賦值成功、失敗作為if判斷的Bool條件

let string : String? = nil
if let constantName = string { // 這里的string必須為可選類型，不然會報錯
    print(constantName)
} else {
    print(constantName)  // 錯誤: 超出constantName作用域
}

使用斷言進行調(diào)試

斷言會在運行時判斷一個邏輯條件是否為true

你可以使用全局assert(_:_file:line:)函數(shù)來寫一個斷言。向這個函數(shù)傳入一個結(jié)果為true或者false的表達式以及一條信息，當表達式的結(jié)果為false的時候這條信息會被顯示：

let age = -3
assert(age >= 0, "A person's age cannot be less than zero")
// 因為 age < 0，所以斷言會觸發(fā)

在這個例子中，只有age >= 0為true的時候，即age的值非負的時候，代碼才會繼續(xù)執(zhí)行。如果age的值是負數(shù)，就像代碼中那樣，age >= 0為false，斷言被觸發(fā)，終止應用。

使用場景:

• 整數(shù)類型的下標索引被傳入一個自定義下標實現(xiàn)，但是下標索引值可能太小或者太大。
• 需要給函數(shù)傳入一個值，但是非法的值可能導致函數(shù)不能正常執(zhí)行。
• 一個可選值現(xiàn)在是nil，但是后面的代碼運行需要一個非nil值。

運算符

Swift 支持大部分標準 C 語言的運算符，且改進許多特性來減少常規(guī)編碼錯誤。如：賦值符（=）不返回值，以防止把想要判斷相等運算符（==）的地方寫成賦值符導致的錯誤

算術(shù)運算符（+，-，*，/，%等）會檢測并不允許值溢出，以此來避免保存變量時由于變量大于或小于其類型所能承載的范圍時導致的異常結(jié)果

區(qū)別于 C 語言，在 Swift 中你可以對浮點數(shù)進行取余運算（%），Swift 還提供了 C 語言沒有的表達兩數(shù)之間的值的區(qū)間運算符（a..<b 和 a...b），這方便我們表達一個區(qū)間內(nèi)的數(shù)值。

8 % 2.5   // 等于 0.5  3個2.5  還剩余一個0.5

當元組中的值可以比較時，你也可以使用這些運算符來比較它們的大小。例如，因為 Int 和 String 類型的值可以比較，所以類型為 (Int, String) 的元組也可以被比較。相反，Bool 不能被比較，也意味著存有布爾類型的元組不能被比較。

比較元組大小會按照從左到右、逐值比較的方式，直到發(fā)現(xiàn)有兩個值不等時停止。如果所有的值都相等，那么這一對元組我們就稱它們是相等的。例如：

(1, "zebra") < (2, "apple")   // true，因為 1 小于 2
(3, "apple") < (3, "bird")    // true，因為 3 等于 3，但是 apple 小于 bird
(4, "dog") == (4, "dog")      // true，因為 4 等于 4，dog 等于 dog

注意： Swift 標準庫只能比較七個以內(nèi)元素的元組比較函數(shù)。如果你的元組元素超過七個時，你需要自己實現(xiàn)比較運算符。

空合運算符

空合運算符（a ?? b）將對可選類型 a 進行空判斷，如果 a 包含一個值就進行解封，否則就返回一個默認值 b。表達式 a 必須是 Optional 類型。默認值 b 的類型必須要和 a 存儲值的類型保持一致。

注意： 如果 a 為非空值（non-nil），那么值 b 將不會被計算。這也就是所謂的短路求值，短路運算符一般有:&&、||,其原理是:當有多個表達式時,左邊的表達式值可以確定結(jié)果時,就不再繼續(xù)運算右邊的表達式的值

閉區(qū)間運算符

閉區(qū)間運算符（a...b）定義一個包含從 a 到 b（包括 a 和 b）的所有值的區(qū)間。a 的值不能超過 b

半開區(qū)間運算符

半開區(qū)間（a..<b）定義一個從 a 到 b 但不包括 b 的區(qū)間

邏輯運算符

邏輯與 或 非運算符的操作數(shù)只能是bool類型，不能是整型等等。Swift 邏輯操作符 && 和 || 是左結(jié)合的

字符串

定義空字符串

var emptyString = ""               // 空字符串字面量
var anotherEmptyString = String()  // 初始化方法
// 兩個字符串均為空并等價。

您可以通過檢查其Bool類型的isEmpty屬性來判斷該字符串是否為空：

if emptyString.isEmpty {
    print("Nothing to see here")
}

字符串是值類型（Strings Are Value Types）

Swift 的String類型是值類型。 如果您創(chuàng)建了一個新的字符串，那么當其進行常量、變量賦值操作，或在函數(shù)/方法中傳遞時，會進行值拷貝。 任何情況下，都會對已有字符串值創(chuàng)建新副本，并對該新副本進行傳遞或賦值操作

在實際編譯時，Swift 編譯器會優(yōu)化字符串的使用，使實際的復制只發(fā)生在絕對必要的情況下，這意味著您將字符串作為值類型的同時可以獲得極高的性能。

另外，通過標明一個Character類型并用字符字面量進行賦值，可以建立一個獨立的字符常量或變量：

let exclamationMark: Character = "!"  // 不能用''，必須雙引號,而且必須指定為Character類型，否則會推斷為string類型

注意： 可擴展的字符群集可以組成一個或者多個 Unicode 標量。這意味著不同的字符以及相同字符的不同表示方式可能需要不同數(shù)量的內(nèi)存空間來存儲。所以 Swift 中的字符在一個字符串中并不一定占用相同的內(nèi)存空間數(shù)量。因此在沒有獲取字符串的可擴展的字符群的范圍時候，就不能計算出字符串的字符數(shù)量。如果您正在處理一個長字符串，需要注意characters屬性必須遍歷全部的 Unicode 標量，來確定字符串的字符數(shù)量。
另外需要注意的是通過characters屬性返回的字符數(shù)量并不總是與包含相同字符的NSString的length屬性相同。NSString的length屬性是利用 UTF-16 表示的十六位代碼單元數(shù)字，而不是 Unicode 可擴展的字符群集。作為佐證，當一個NSString的length屬性被一個Swift的String值訪問時，實際上是調(diào)用了utf16Count。

字符串索引

每一個String值都有一個關(guān)聯(lián)的索引(index)類型，String.Index，它對應著字符串中的每一個Character的位置。

前面提到，不同的字符可能會占用不同數(shù)量的內(nèi)存空間，所以要知道Character的確定位置，就必須從String開頭遍歷每一個 Unicode 標量直到結(jié)尾。因此，Swift 的字符串不能用整數(shù)(integer)做索引。

使用startIndex屬性可以獲取一個String的第一個Character的索引。使用endIndex屬性可以獲取最后一個Character的后一個位置的索引。因此，endIndex屬性不能作為一個字符串的有效下標。如果String是空串，startIndex和endIndex是相等的。

let greeting = "Guten Tag!"
greeting[greeting.startIndex] // G
greeting[greeting.endIndex.predecessor()]  // !
greeting[greeting.startIndex.successor()]  // u
let index = greeting.startIndex.advancedBy(7) // 這個比較常用，()里面可以是負值
greeting[index]   // a

如果字符串索引越界，則運行時錯誤

字符串/字符相等

字符串/字符可以用等于操作符(==)和不等于操作符(!=)

如果兩個字符串（或者兩個字符）的可擴展的字形群集是標準相等的，那就認為它們是相等的。在這個情況下，即使可擴展的字形群集是有不同的 Unicode 標量構(gòu)成的，只要它們有同樣的語言意義和外觀，就認為它們標準相等。

相反，英語中的LATIN CAPITAL LETTER A(U+0041，或者A)不等于俄語中的CYRILLIC CAPITAL LETTER A(U+0410，或者A)。兩個字符看著是一樣的，但卻有不同的語言意義

前綴/后綴相等 (Prefix and Suffix Equality)

通過調(diào)用字符串的hasPrefix(_:)/hasSuffix(_:)方法來檢查字符串是否擁有特定前綴/后綴，兩個方法均接收一個String類型的參數(shù)，并返回一個布爾值.

let astring = "123456"
astring.hasPrefix("123") // true
astring.hasSuffix("456") // true

Arrays、Sets和Dictionaries三種集合

Swift 語言提供Arrays、Sets和Dictionaries三種基本的集合類型用來存儲集合數(shù)據(jù)。數(shù)組（Arrays）是有序數(shù)據(jù)的集。集合（Sets）是無序無重復數(shù)據(jù)的集。字典（Dictionaries）是無序的鍵值對的集

Swift 語言中的Arrays、Sets和Dictionaries中存儲的數(shù)據(jù)值類型必須明確。這意味著我們不能把不正確的數(shù)據(jù)類型插入其中。同時這也說明我們完全可以對取回值的類型非常自信

對于無序集合 可以使用sort()來進行排序

數(shù)組(Arrays)

數(shù)組使用有序列表存儲同一類型的多個值，可選類型與一般類型不能同一存儲(隱式解析可選類型可以當做一般類型使用)。相同的值可以多次出現(xiàn)在一個數(shù)組的不同位置中。如果初始化時，所有內(nèi)容類型一致，擇數(shù)組中保存的是該類型的內(nèi)容
如果初始化時，所有內(nèi)容類型不一致，則數(shù)組中保存的是 NSObject，類型一旦確定則不能改變

var someInts = [Int]() // 定義
someInts = []   // someInts 現(xiàn)在是空數(shù)組，但是仍然是 [Int] 類型的。

如果數(shù)組定義為let，則數(shù)組的內(nèi)容不能改變，數(shù)組本身也不能變。如果是var則兩者都可變，另外

創(chuàng)建一個帶有默認值的數(shù)組

Swift 中的Array類型還提供一個可以創(chuàng)建特定大小并且所有數(shù)據(jù)都被默認的構(gòu)造方法

var threeDoubles = [Double](count: 3, repeatedValue:0.0)
// threeDoubles 是一種 [Double] 數(shù)組，等價于 [0.0, 0.0, 0.0]

通過兩個數(shù)組相加創(chuàng)建一個數(shù)組

我們可以使用加法操作符（+）來組合兩種已存在的相同類型數(shù)組。新數(shù)組的數(shù)據(jù)類型會被從兩個數(shù)組的數(shù)據(jù)類型中推斷出來：

var anotherThreeDoubles = Array(count: 3, repeatedValue: 2.5)
// anotherThreeDoubles 被推斷為 [Double]，等價于 [2.5, 2.5, 2.5]

var sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles 被推斷為 [Double]，等價于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

使用加法賦值運算符（+=）也可以直接在數(shù)組后面添加一個或多個擁有相同類型的數(shù)據(jù)項：

shoppingList += ["Baking Powder"]
// shoppingList 現(xiàn)在有四項了
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
// shoppingList 現(xiàn)在有七項了

還可以利用下標來一次改變一系列數(shù)據(jù)值，即使新數(shù)據(jù)和原有數(shù)據(jù)的數(shù)量是不一樣的。下面的例子把"Chocolate Spread"，"Cheese"，和"Butter"替換為"Bananas"和 "Apples"：

shoppingList[4...6] = ["Bananas", "Apples"]

如果我們只想把數(shù)組中的最后一項移除，可以使用removeLast()方法

不可以用下標訪問的形式去在數(shù)組尾部添加新項。

如果我們同時需要每個數(shù)據(jù)項的值和索引值，可以使用enumerate()方法來進行數(shù)組遍歷。enumerate()返回一個由每一個數(shù)據(jù)項索引值和數(shù)據(jù)值組成的元組。我們可以把這個元組分解成臨時常量或者變量來進行遍歷：

for (index, value) in shoppingList.enumerate() {
    print("Item \(String(index + 1)): \(value)")
}

集合（Sets）

集合(Set)用來存儲相同類型并且沒有確定順序的值。當集合元素順序不重要時或者希望確保每個元素只出現(xiàn)一次時可以使用集合而不是數(shù)組。

集合類型的哈希值

一個類型為了存儲在集合中，該類型必須是可哈希化的--也就是說，該類型必須提供一個方法來計算它的哈希值。一個哈希值是Int類型的，相等的對象哈希值必須相同，比如a==b,因此必須a.hashValue == b.hashValue。

var letters = Set<Character>()  // 創(chuàng)建和構(gòu)造一個空的集合
letters = []  // letters 現(xiàn)在是一個空的 Set, 但是它依然是 Set<Character> 類型
var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]

一般操作

一個Set類型不能從數(shù)組字面量中被單獨推斷出來，因此Set類型必須顯式聲明。然而，由于 Swift 的類型推斷功能，如果你想使用一個數(shù)組字面量構(gòu)造一個Set并且該數(shù)組字面量中的所有元素類型相同，那么你無須寫出Set的具體類型

var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]

你可以通過調(diào)用Set的insert(_:)方法來添加一個新元素，你可以通過調(diào)用Set的remove(_:)方法去刪除一個元素，如果該值是該Set的一個元素則刪除該元素并且返回被刪除的元素值，否則如果該Set不包含該值，則返回nil。另外，Set中的所有元素可以通過它的removeAll()方法刪除。使用contains(_:)方法去檢查Set中是否包含一個特定的值,你可以在一個for-in循環(huán)中遍歷一個Set中的所有值。

集合比較

• 使用intersect(_:)方法根據(jù)兩個集合中都包含的值創(chuàng)建的一個新的集合。
• 使用exclusiveOr(_:)方法根據(jù)在一個集合中但不在兩個集合中的值創(chuàng)建一個新的集合。
• 使用union(_:)方法根據(jù)兩個集合的值創(chuàng)建一個新的集合。
• 使用subtract(_:)方法根據(jù)不在該集合中的值創(chuàng)建一個新的集合。

字典

字典是一種存儲多個相同類型的值的容器。每個值（value）都關(guān)聯(lián)唯一的鍵（key），鍵作為字典中的這個值數(shù)據(jù)的標識符。和數(shù)組中的數(shù)據(jù)項不同，字典中的數(shù)據(jù)項并沒有具體順序

字典類型快捷語法

Swift 的字典使用Dictionary<Key, Value>定義，我們也可以用[Key: Value]這樣快捷的形式去創(chuàng)建一個字典類型。雖然這兩種形式功能上相同，但是后者是首選，并且這本指導書涉及到字典類型時通篇采用后者。

和數(shù)組一樣，我們在用字典字面量構(gòu)造字典時，如果它的鍵和值都有各自一致的類型，那么就不必寫出字典的類型。

創(chuàng)建一個空字典

我們可以像數(shù)組一樣使用構(gòu)造語法創(chuàng)建一個擁有確定類型的空字典：

var namesOfIntegers = [Int: String]()  // namesOfIntegers 是一個空的 [Int: String] 字典

這個例子創(chuàng)建了一個[Int: String]類型的空字典來儲存整數(shù)的英語命名。它的鍵是Int型，值是String型。

如果上下文已經(jīng)提供了類型信息，我們可以使用空字典字面量來創(chuàng)建一個空字典，記作[:]（中括號中放一個冒號）：

namesOfIntegers[16] = "sixteen"
// namesOfIntegers 現(xiàn)在包含一個鍵值對
namesOfIntegers = [:]
// namesOfIntegers 又成為了一個 [Int: String] 類型的空字典

用字典字面量創(chuàng)建字典
我們可以使用字典字面量來構(gòu)造字典，這和我們剛才介紹過的數(shù)組字面量擁有相似語法。字典字面量是一種將一個或多個鍵值對寫作Dictionary集合的快捷途徑。

一個鍵值對是一個key和一個value的結(jié)合體。在字典字面量中，每一個鍵值對的鍵和值都由冒號分割。這些鍵值對構(gòu)成一個列表，其中這些鍵值對由方括號包含、由逗號分割：

[key 1: value 1, key 2: value 2, key 3: value 3]

iocoresurfaceroot

控制流

Swift 的switch語句比 C 語言中更加強大。在 C 語言中，如果某個 case 不小心漏寫了break，這個 case 就會貫穿至下一個 case，Swift 無需寫break，所以不會發(fā)生這種貫穿的情況，但你仍然可以在末尾寫入break，來正?；蛱崆敖Y(jié)束。case 還可以匹配更多的類型模式，包括區(qū)間匹配（range matching），元組（tuple）和特定類型的描述。switch的 case 語句中匹配的值可以是由 case 體內(nèi)部臨時的常量或者變量決定，也可以由where分句描述更復雜的匹配條件。

For-In 循環(huán)

如果你不需要知道區(qū)間序列內(nèi)每一項的值，你可以使用下劃線（_）替代變量名來忽略對值的訪問：

let base = 3
let power = 10
var answer = 1
for _ in 1...power {
    answer *= base
}

repeat-while循環(huán)合其他語言中的do-while循環(huán)是類似的

switch語句必須是完備的，即必須有default分支，除非是字面常量，否則報錯，如下：

switch 10 {
case 10:
    print("10")
}
/// 或者是窮舉枚舉類型也可以不用default

另外，可以有多個匹配，如果有多個匹配則只執(zhí)行第一個，break語句是跳出當前循環(huán)，或者是跳出switch分支，因此在其它地方使用swift中會報錯，而continue只允許在循環(huán)里面使用。每個分支必須至少有一條執(zhí)行語句，包括default分支

如果你確實需要 C 風格的貫穿的特性，你可以在每個需要該特性的 case 分支中使用fallthrough關(guān)鍵字，將自動執(zhí)行下一個分支.

標簽語句

在 Swift 中，你可以在循環(huán)體和switch代碼塊中嵌套循環(huán)體和switch代碼塊來創(chuàng)造復雜的控制流結(jié)構(gòu)。然而，循環(huán)體和switch代碼塊兩者都可以使用break語句來提前結(jié)束整個方法體。因此，顯式地指明break語句想要終止的是哪個循環(huán)體或者switch代碼塊，會很有用。類似地，如果你有許多嵌套的循環(huán)體，顯式指明continue語句想要影響哪一個循環(huán)體也會非常有用。

labelName: while condition { statements }

gameLoop: while square != finalSquare {
    switch square + diceRoll {
    case finalSquare:
        break gameLoop // 跳出while循環(huán)
    case let newSquare where newSquare > finalSquare:
        continue gameLoop // 開始新的while循環(huán)
    }
}

檢測 API 可用性

if #available(iOS 9, OSX 10.10, *) {
    // 在 iOS 使用 iOS 9 的 API, 在 OS X 使用 OS X v10.10 的 API
} else {
    // 使用先前版本的 iOS 和 OS X 的 API
}

以上可用性條件指定在 iOS，if段的代碼僅僅在 iOS 9 及更高可運行；在 OS X，僅在 OS X v10.10 及更高可運行。最后一個參數(shù)，*，是必須的并且指定在任何其他平臺上，if段的代碼在最小可用部署目標指定項目中執(zhí)行。