最近項目使用的是OC，后頭看之前用Swift開發(fā)的一個項目時，發(fā)現(xiàn)很多細節(jié)都忘記了????。
為了回憶和以后方便查看，現(xiàn)在根據(jù)官方文檔swift編程語言，做下筆記。
1、 常量和變量必須在使用前聲明：
用 let來聲明常量；
用 var 來聲明變量。
let maximumNumberOfLoginAttempts = 10
表示：聲明一個名字是 maximumNumberOfLoginAttempts 的新常量，并給它一個值 10 。
var currentLoginAttempt = 0
表示：聲明一個名字是 currentLoginAttempt 的變量并將它的值初始化為 0 。
2、 類型標注
當你聲明常量或者變量的時候可以加上類型標注（type annotation），說明常量或者變量中要存儲的值的類型。如果要添加類型標注，需要在常量或者變量名后面加上一個冒號和空格，然后加上類型名稱。
var welcomeMessage: String
聲明一個類型為 String ，名字為 welcomeMessage 的變量。
一般來說你很少需要寫類型標注。如果你在聲明常量或者變量的時候賦了一個初始值，Swift可以推斷出這個常量或者變量的類型。
3、 輸出
Swift 用字符串插值（string interpolation）的方式把常量名或者變量名當做占位符加入到長字符串中，Swift 會用當前常量或變量的值替換這些占位符。將常量或變量名放入圓括號中，并在開括號前使用反斜杠將其轉(zhuǎn)義：
var friendlyWelcome = "Hello!"
print("The current value of friendlyWelcome is (friendlyWelcome)")
// 輸出 "The current value of friendlyWelcome is Hello!
4、 分號
Swift 并不強制要求你在每條語句的結(jié)尾處使用分號（;）當然也可以按照自己的習慣添加分號。有一種情況下必須要用分號，即你打算在同一行內(nèi)寫多條獨立的語句：
let cat = "??"; print(cat)
// 輸出 "??"
5、 整數(shù)
- Int
一般來說，你不需要專門指定整數(shù)的長度。Swift 提供了一個特殊的整數(shù)類型Int，長度與當前平臺的原生字長相同
在32位平臺上，Int 和 Int32 長度相同。
在64位平臺上，Int 和 Int64 長度相同。
注意：除非你需要特定長度的整數(shù)，一般來說使用 Int 就夠了。這可以提高代碼一致性和可復用性。即使是在32位平臺上，Int 可以存儲的整數(shù)范圍也可以達到 -2,147,483,648 ~ 2,147,483,647 ，大多數(shù)時候這已經(jīng)足夠大了。
6、類型安全和類型推斷
Swift 是類型安全的，它會在編譯你的代碼時進行類型檢查（type checks），并把不匹配的類型標記為錯誤。這可以讓你在開發(fā)的時候盡早發(fā)現(xiàn)并修復錯誤。
- 如果你給一個新常量賦值 42 并且沒有標明類型，Swift 可以推斷出常量類型是 Int
let meaningOfLife = 42
// meaningOfLife 會被推測為 Int 類型
- 如果你沒有給浮點字面量標明類型，Swift 會推斷你想要的是 Double：
當推斷浮點數(shù)的類型時，Swift 總是會選擇 Double 而不是Float。
let pi = 3.14159
// pi 會被推測為 Double 類型
- 如果表達式中同時出現(xiàn)了整數(shù)和浮點數(shù)，會被推斷為 Double 類型：
let anotherPi = 3 + 0.14159
// anotherPi 會被推測為 Double 類型
原始值 3 沒有顯式聲明類型，而表達式中出現(xiàn)了一個浮點字面量，所以表達式會被推斷為 Double 類型。
7、 元祖
元組（tuples）把多個值組合成一個復合值。元組內(nèi)的值可以是任意類型，并不要求是相同類型。
let http404Error = (404, "Not Found")
// http404Error 的類型是 (Int, String)，值是 (404, "Not Found")
(404, "Not Found") 元組把一個 Int 值和一個 String 值組合起來表示 HTTP 狀態(tài)碼的兩個部分。
這個元組可以被描述為“一個類型為 (Int, String) 的元組”。
- 你可以將一個元組的內(nèi)容分解（decompose）成單獨的常量和變量，然后你就可以正常使用它們了：
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)體而不是元組。
8、可選類型
在值可能為空的情況下，你可以使用可選類型；可選類型有兩種可能性：
1：有值，解析取值
2：沒有值
-
下面的例子使用這種構(gòu)造器來嘗試將一個 String 轉(zhuǎn)換成 Int：
let possibleNumber = "123"
let convertedNumber = Int(possibleNumber)
// convertedNumber 被推測為類型 "Int?"， 或者類型 "optional Int"
因為該構(gòu)造器可能會失敗，所以它返回一個可選類型（optional）Int，而不是一個 Int。一個可選的 Int 被寫作 Int? 而不是 Int。問號暗示包含的值是可選類型，也就是說可能包含 Int 值也可能不包含值。不能包含其他任何值比如 Bool 值或者 String 值。只能是 Int 或者什么都沒有。）
-
nil
Swift 的 nil 和 Objective-C 中的 nil 并不一樣。在 Objective-C 中，nil 是一個指向不存在對象的指針。在 Swift 中，nil 不是指針——它是一個確定的值，用來表示值缺失。任何類型的可選狀態(tài)都可以被設(shè)置為 nil，不只是對象類型。
你可以給可選變量賦值為nil來表示它沒有值：
var serverResponseCode: Int? = 404
// serverResponseCode 包含一個可選的 Int 值 404
serverResponseCode = nil
// serverResponseCode 現(xiàn)在不包含值
注意 nil不能用于非可選的常量和變量。如果你的代碼中有常量或者變量需要處理值缺失的情況，請把它們聲明成對應(yīng)的可選類型。
-
if語句
你可以使用 if 語句和 nil 比較來判斷一個可選值是否包含值。你可以使用“相等”(==)或“不等”(!=)來執(zhí)行比較。
if convertedNumber != nil {
print("convertedNumber contains some integer value.")
}
// 輸出 "convertedNumber contains some integer value."
-
強制解析
當你確定可選類型確實包含值之后，你可以在可選的名字后面加一個感嘆號（!）來獲取值。這個驚嘆號表示“我知道這個可選有值，請使用它。
let possibleNumber = "123"
let convertedNumber = Int(possibleNumber)
// convertedNumber 被推測為類型 "Int?"， 或者類型 "optional Int"
print("convertedNumber has an integer value of (convertedNumber!).")
// 輸出 "convertedNumber has an integer value of 123."
-
可選綁定
使用可選綁定（optional binding）來判斷可選類型是否包含值，如果包含就把值賦給一個臨時常量或者變量。可選綁定可以用在 if 和 while 語句中，這條語句不僅可以用來判斷可選類型中是否有值，同時可以將可選類型中的值賦給一個常量或者變量。
let possibleNumber = "123"
if let actualNumber = Int(possibleNumber) {
print("'(possibleNumber)' has an integer value of (actualNumber)")
} else {
print("'(possibleNumber)' could not be converted to an integer")
}
// 輸出 "'123' has an integer value of 123"
這段代碼可以被理解為：
如果 Int(possibleNumber) 返回的可選 Int 包含一個值，創(chuàng)建一個叫做 actualNumber 的新常量并將可選包含的值賦給它。
有值的話，actualNumber 常量可以在 if 語句的第一個分支中使用。它已經(jīng)被可選類型 包含的 值初始化過，所以不需要再使用 ! 后綴來獲取它的值。
-
隱式解析可選類型
有時候在程序架構(gòu)中，第一次被賦值之后，可以確定一個可選類型總會有值。這時候把想要用作可選的類型的后面的問號（String?）改成感嘆號（String!）來聲明一個隱式解析可選類型。
普通的可選類型
let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // 需要感嘆號來獲取值
隱式解析可選類型
let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString // 不需要感嘆號
一個隱式解析可選類型其實就是一個普通的可選類型，但是可以被當做非可選類型來使用，并不需要每次都使用解析來獲取可選值。
9、區(qū)間運算符
- 閉區(qū)間運算符
a...b定義一個包含從 a 到 b（包括 a 和 b）的所有值的區(qū)間。a 的值不能超過 b。 - 半開區(qū)間運算符
a..<b定義一個從 a 到 b 但不包括 b 的區(qū)間。
10、 字符串
-
Swift 的String類型是值類型。 如果您創(chuàng)建了一個新的字符串，那么當其進行常量、變量賦值操作，或在函數(shù)/方法中傳遞時，會進行值拷貝。 任何情況下，都會對已有字符串值創(chuàng)建新副本，并對該新副本進行傳遞或賦值操作。
11、集合類型
Swift 語言提供Arrays、Sets和Dictionaries三種基本的集合類型用來存儲集合數(shù)據(jù)。
數(shù)組（Arrays）是有序數(shù)據(jù)的集。
集合（Sets）是無序無重復數(shù)據(jù)的集。
字典（Dictionaries）是無序的鍵值對的集。
注意：Swift 的Arrays、Sets和Dictionaries類型被實現(xiàn)為泛型集合。
如果創(chuàng)建一個Arrays、Sets或Dictionaries并且把它分配成一個變量，這個集合將會是可變的。這意味著我們可以在創(chuàng)建之后添加更多或移除已存在的數(shù)據(jù)項，或者改變集合中的數(shù)據(jù)項。如果我們把Arrays、Sets或Dictionaries分配成常量，那么它就是不可變的，它的大小和內(nèi)容都不能被改變。
-
數(shù)組(Arrays)
數(shù)組使用有序列表存儲同一類型的多個值。相同的值可以多次出現(xiàn)在一個數(shù)組的不同位置中。
1、 創(chuàng)建一個空數(shù)組
var someInts = [Int] ()
print("someInts is of type [Int] with (someInts.count) items.")
// 打印 "someInts is of type [Int] with 0 items."
someInts的值類型被推斷為[Int]
2、創(chuàng)建一個帶有默認值的數(shù)組
Swift 中的Array類型還提供一個可以創(chuàng)建特定大小并且所有數(shù)據(jù)都被默認的構(gòu)造方法。我們可以把準備加入新數(shù)組的數(shù)據(jù)項數(shù)量（count）和適當類型的初始值（repeating）傳入數(shù)組構(gòu)造函數(shù)：
var threeDoubles = Array(repeating: 0.0, count: 3)
// threeDoubles 是一種 [Double] 數(shù)組，等價于 [0.0, 0.0, 0.0]
3、通過兩個數(shù)組相加創(chuàng)建一個數(shù)組
我們可以使用加法操作符（+）來組合兩種已存在的相同類型數(shù)組。新數(shù)組的數(shù)據(jù)類型會被從兩個數(shù)組的數(shù)據(jù)類型中推斷出來：
var anotherThreeDoubles = Array(repeating: 2.5, count: 3)
// 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]
4、用數(shù)組字面量構(gòu)造數(shù)組
數(shù)組字面量是一系列由逗號分割并由方括號包含的數(shù)值
var shoppingList: [String] = ["Eggs", "Milk"]
// shoppingList 已經(jīng)被構(gòu)造并且擁有兩個初始項。
還可以等價于
var shoppingList = ["Eggs", "Milk"]
因為所有數(shù)組字面量中的值都是相同的類型，Swift 可以推斷出[String]是shoppingList中變量的正確類型。
5、訪問和修改數(shù)組
我們可以通過數(shù)組的方法和屬性來訪問和修改數(shù)組，或者使用下標語法。
可以使用數(shù)組的只讀屬性count來獲取數(shù)組中的數(shù)據(jù)項數(shù)量
var shoppingList = ["Eggs", "Milk"]
print("The shopping list contains (shoppingList.count) items.")
// 輸出 "The shopping list contains 2 items."（這個數(shù)組有2個項）
使用布爾屬性isEmpty作為一個縮寫形式去檢查count屬性是否為0：
if shoppingList.isEmpty {
print("The shopping list is empty.")
} else {
print("The shopping list is not empty.")
}
// 打印 "The shopping list is not empty."（shoppinglist 不是空的）
也可以使用append(_:)方法在數(shù)組后面添加新的數(shù)據(jù)項：
shoppingList.append("Flour")
// shoppingList 現(xiàn)在有3個數(shù)據(jù)項
使用加法賦值運算符（+=）也可以直接在數(shù)組后面添加一個或多個擁有相同類型的數(shù)據(jù)項：
shoppingList += ["Baking Powder"]
// shoppingList 現(xiàn)在有四項了
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
// shoppingList 現(xiàn)在有七項了
我們也可以用下標來改變某個已有索引值對應(yīng)的數(shù)據(jù)值：
shoppingList[0] = "Six eggs"
// 其中的第一項現(xiàn)在是 "Six eggs" 而不是 "Eggs"
還可以利用下標來一次改變一系列數(shù)據(jù)值，即使新數(shù)據(jù)和原有數(shù)據(jù)的數(shù)量是不一樣的。下面的例子把"Chocolate Spread"，"Cheese"，和"Butter"替換為"Bananas"和 "Apples"：
shoppingList[4...6] = ["Bananas", "Apples"]
// shoppingList 現(xiàn)在有6項
調(diào)用數(shù)組的insert(_:at:)方法來在某個具體索引值之前添加數(shù)據(jù)項：
shoppingList.insert("Maple Syrup", at: 0)
// shoppingList 現(xiàn)在有7項
// "Maple Syrup" 現(xiàn)在是這個列表中的第一項
我們可以使用remove(at:)方法來移除數(shù)組中的某一項。這個方法把數(shù)組在特定索引值中存儲的數(shù)據(jù)項移除并且返回這個被移除的數(shù)據(jù)項（我們不需要的時候就可以無視它）：
let mapleSyrup = shoppingList.remove(at: 0)
// 索引值為0的數(shù)據(jù)項被移除
// shoppingList 現(xiàn)在只有6項，而且不包括 Maple Syrup
// mapleSyrup 常量的值等于被移除數(shù)據(jù)項的值 "Maple Syrup"
6、數(shù)組的遍歷
我們可以使用for-in循環(huán)來遍歷所有數(shù)組中的數(shù)據(jù)項：
for item in shoppingList {
print(item)
}
// Six eggs
// Milk
// Flour
// Baking Powder
// Bananas
// Apples
如果我們同時需要每個數(shù)據(jù)項的值和索引值，可以使用enumerated()方法來進行數(shù)組遍歷。enumerated()返回一個由每一個數(shù)據(jù)項索引值和數(shù)據(jù)值組成的元組。我們可以把這個元組分解成臨時常量或者變量來進行遍歷：
for (index, value) in shoppingList. enumerated() {
print("Item (String(index + 1)): (value)")
}
// Item 1: Six eggs
// Item 2: Milk
// Item 3: Flour
// Item 4: Baking Powder
// Item 5: Bananas
// Item 5: Apples
-
集合（Sets）
用來存儲相同類型并且沒有確定順序的值。當集合元素順序不重要時或者希望確保每個元素只出現(xiàn)一次時可以使用集合。
一個Set類型不能從數(shù)組字面量中被單獨推斷出來，因此Set類型必須顯式聲明。然而，由于 Swift 的類型推斷功能，如果你想使用一個數(shù)組字面量構(gòu)造一個Set并且該數(shù)組字面量中的所有元素類型相同，那么你無須寫出Set的具體類型。favoriteGenres的構(gòu)造形式可以采用簡化的方式代替：
var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]
由于數(shù)組字面量中的所有元素類型相同，Swift 可以推斷出Set<String>作為favoriteGenres變量的正確類型。
-
字典（Dictionaries）
是一種存儲多個相同類型的值的容器。每個值（value）都關(guān)聯(lián)唯一的鍵（key），鍵作為字典中的這個值數(shù)據(jù)的標識符。和數(shù)組中的數(shù)據(jù)項不同，字典中的數(shù)據(jù)項并沒有具體順序。
Swift 的字典使用Dictionary<Key, Value>定義，其中Key是字典中鍵的數(shù)據(jù)類型，Value是字典中對應(yīng)于這些鍵所存儲值的數(shù)據(jù)類型。
也可以用[Key: Value]這樣簡化的形式去創(chuàng)建一個字典類型。
1、創(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)建字典
var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
//airports字典被聲明為一種[String: String]類型，這意味著這個字典的鍵和值都是String類型。
和數(shù)組一樣，我們在用字典字面量構(gòu)造字典時，如果它的鍵和值都有各自一致的類型，那么就不必寫出字典的類型。 airports字典也可以用這種簡短方式定義
var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
//這個語句中所有的鍵和值都各自擁有相同的數(shù)據(jù)類型，Swift 可以推斷出Dictionary<String, String>是airports字典的正確類型。
2、訪問和修改字典
我們可以通過字典的方法和屬性來訪問和修改字典，或者通過使用下標語法。
和數(shù)組一樣，我們可以通過字典的只讀屬性count來獲取某個字典的數(shù)據(jù)項數(shù)量：
var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
print("The dictionary of airports contains (airports.count) items.")
// 打印 "The dictionary of airports contains 2 items."（這個字典有兩個數(shù)據(jù)項）
使用布爾屬性isEmpty作為一個縮寫形式去檢查count屬性是否為0：
if airports.isEmpty {
print("The airports dictionary is empty.")
} else {
print("The airports dictionary is not empty.")
}
// 打印 "The airports dictionary is not empty."
我們也可以在字典中使用下標語法來添加新的數(shù)據(jù)項?？梢允褂靡粋€恰當類型的鍵作為下標索引，并且分配恰當類型的新值：
airports["LHR"] = "London"
// airports 字典現(xiàn)在有三個數(shù)據(jù)項
我們也可以使用下標語法來改變特定鍵對應(yīng)的值：
airports["LHR"] = "London Heathrow"
// "LHR"對應(yīng)的值 被改為 "London Heathrow
可以使用下標語法來在字典中檢索特定鍵對應(yīng)的值。因為有可能請求的鍵沒有對應(yīng)的值存在，字典的下標訪問會返回對應(yīng)值的類型的可選值。如果這個字典包含請求鍵所對應(yīng)的值，下標會返回一個包含這個存在值的可選值，否則將返回nil：
if let airportName = airports["DUB"] {
print("The name of the airport is (airportName).")
} else {
print("That airport is not in the airports dictionary.")
}
// 打印 "The name of the airport is Dublin"
我們還可以使用下標語法來通過給某個鍵的對應(yīng)值賦值為nil來從字典里移除一個鍵值對：
airports["APL"] = "Apple Internation"
// "Apple Internation" 不是真的 APL 機場, 刪除它
airports["APL"] = nil
// APL 現(xiàn)在被移除了
3、字典遍歷
我們可以使用for-in循環(huán)來遍歷某個字典中的鍵值對。每一個字典中的數(shù)據(jù)項都以(key, value)元組形式返回，并且我們可以使用臨時常量或者變量來分解這些元組：
for (airportCode, airportName) in airports {
print("(airportCode): (airportName)")
}
// YYZ: Toronto Pearson
// DUB: Dublin
// LHR: London Heathrow
通過訪問keys或者values屬性，我們也可以遍歷字典的鍵或者值：
for airportCode in airports.keys {
print("Airport code: (airportCode)")
}
// Airport code: YYZ
// Airport code: DUB
// Airport code: LHR
for airportName in airports.values {
print("Airport name: (airportName)")
}
// Airport name: Toronto Pearson
// Airport name: Dublin
// Airport name: London Heathrow
如果我們只是需要使用某個字典的鍵集合或者值集合來作為某個接受Array實例的 API 的參數(shù)，可以直接使用keys或者values屬性構(gòu)造一個新數(shù)組：
let airportCodes = [String] (airports.keys)
// airportCodes 是 ["YYZ","DUB", "LHR"]
12、控制流
-
Switch
在 Swift 中，當匹配的 case 分支中的代碼執(zhí)行完畢后，程序會終止switch語句，而不會繼續(xù)執(zhí)行下一個 case 分支。這也就是說，不需要在 case 分支中顯式地使用break語句。
每一個 case 分支都必須包含至少一條語句。像下面這樣書寫代碼是無效的，因為第一個 case 分支是空的：
let anotherCharacter: Character = "a"
switch anotherCharacter {
case "a": // 無效，這個分支下面沒有語句
case "A":
print("The letter A")
default:
print("Not the letter A")
}
// 這段代碼會報編譯錯誤
-
Early Exit
像if語句一樣，guard的執(zhí)行取決于一個表達式的布爾值。我們可以使用guard語句來要求條件必須為真時，以執(zhí)行g(shù)uard語句后的代碼。不同于if語句，一個guard語句總是有一個else從句，如果條件不為真則執(zhí)行else從句中的代碼。
func greet(person: [String: String]) {
guard let name = person["name"] else {
return
}
print("Hello (name)")
guard let location = person["location"] else {
print("I hope the weather is nice near you.")
return
}
print("I hope the weather is nice in (location).")
}
greet(["name": "John"])
// 輸出 "Hello John!"
// 輸出 "I hope the weather is nice near you."
greet(["name": "Jane", "location": "Cupertino"])
// 輸出 "Hello Jane!"
// 輸出 "I hope the weather is nice in Cupertino."
相比于可以實現(xiàn)同樣功能的if語句，按需使用guard語句會提升我們代碼的可讀性。它可以使你的代碼連貫的被執(zhí)行而不需要將它包在else塊中，它可以使你在緊鄰條件判斷的地方，處理違規(guī)的情況。
-
Checking API Availability
我們在if或guard語句中使用可用性條件（availability condition)去有條件的執(zhí)行一段代碼，來在運行時判斷調(diào)用的API是否可用。編譯器使用從可用性條件語句中獲取的信息去驗證，在這個代碼塊中調(diào)用的 API 是否可用。
if #available(iOS 10, macOS 10.12, *) {
// 在 iOS 使用 iOS 10 的 API, 在 macOS 使用 macOS 10.12 的 API
} else {
// 使用先前版本的 iOS 和 macOS 的 API
}
以上可用性條件指定，if語句的代碼塊僅僅在 iOS 10 或 macOS 10.12 及更高版本才運行。最后一個參數(shù)，*，是必須的，用于指定在所有其它平臺中，如果版本號高于你的設(shè)備指定的最低版本，if語句的代碼塊將會運行。
