| 名稱 | 作用 |
|---|---|
| 控制台輸出 | |
| var | 宣告一個變數 |
| let | 宣告一個常量 |
| if…else… | 條件判斷 |
| switch…case… | 分支判斷 |
| for | 循環 |
| while | 先判斷後循環 |
向控制台輸出 log。
print("hello world") // 輸出純字串
print("1 + \(1) = ?") // 字串插值:括號內可放任意內容,輸出 1 + 1 = ?
var a: Float = 2.1
print("1 + \(a)") // 字串 + 變數,輸出 1 + 2.1
宣告一個變數,代表可以修改的資料,可重複賦值。
var a: Int = 0 a = 100 // 可以再次賦值 var b: NSObject = NSObject()
宣告一個不可變的常量,只能賦值一次。
let a: Int = 0 a = 100 // 這行會報錯,不可再次賦值
條件判斷。與 Objective-C 相比主要有三點差異:
1. 條件不一定要放在小括號中;
2. 條件必須是明確的 true 或 false——0 與非 0 不會隱式轉為布林值,nil 與非 nil 同樣不會;
3. 執行敘述必須包在大括號中。
let a: Int = 0
if a == 0 {
a = 100 // 條件成立時執行
} else {
a = 50 // 條件不成立時執行
}
關鍵字說明:
switch 判斷敘述的起首關鍵字。
case 每個判斷節點的關鍵字。
fallthrough 不跳出判斷,繼續往下執行。
default 例外,所有條件都不成立時執行。
where 判斷子句,相當於 if 敘述中的 &&。
Swift 的 switch 預設只匹配一個 case,這與其他類 C 語言不同。類 C 語言中若不寫 break,就會執行匹配到的 case 及其下方的所有程式碼;而在 Swift 裡不需要 break 來跳出,預設就只執行匹配節點與下一節點之間的程式碼,也不需要大括號包裹。若想繼續往下執行,才加上 fallthrough。
let a = 0
switch a {
case 0: // 匹配成功,執行以下敘述
print("0") // 輸出 0
fallthrough // 繼續執行下一個節點
case 1: // 條件不成立,但因為上一行的 fallthrough 仍會執行
print("1") // 輸出 1
case 2: // 不匹配,不執行
print("2")
default: // 預設節點,不執行
print("3")
}
// 輸出結果:
// 0
// 1
Swift 的 switch 更強大,除了普通的常量匹配,還支援範圍匹配、元組匹配與 where 子句匹配。
1. 範圍匹配
let a = 5
switch a {
case 0...10: // a 是否落在 0 - 10 這 11 個值之間
print("0")
case 0..<10: // a 是否落在 0 - 9 這 10 個值之間
print("1") // 條件雖成立,但第一個 case 已匹配,這裡不會進入
default:
print("2")
}
// 輸出結果:0
2. 元組匹配
let a = (1, 2, "A")
switch a {
case let b: // 絕對匹配的寫法
print("\(b.0)") // 輸出元組第一個元素:1
case (1, 2, let c): // 匹配第一、二個元素,把第三個元素賦值給 c
print("\(c)") // 輸出 A
case (_, let c, "A"): // 忽略第一個元素,第二個賦值給 c,比對第三個元素
print("\(c)") // 輸出 2
default:
print("2")
}
// 輸出結果:1
更多元組用法可參考元組相關章節。
3. where 子句
let a = 1
switch a {
case 1 where false: // 值是 1,但 where 後為 false,條件不成立
print("1")
case 1 where a == 1: // 值是 1 且 where 後為 true,匹配成功
print("2")
}
// 輸出結果:2
附註:Swift 的 switch 預設只匹配一個 case,需要匹配多個時要加 fallthrough;Swift 的 switch 沒有 break,若在其中使用 break,跳出的是更外層的範圍,而不是 switch 本身。
與 Objective-C 相比,循環條件不需要小括號,並新增了區間運算符 ... 與 ..<,取代 i = 0; i < 10; i++ 這類寫法。
for i in 0..<10 { // 半開區間,代表 0 - 9
print("i = \(i)")
}
// 另有全閉區間 0...10,代表 0 - 10
// 效果等同於:
// for var i = 0; i < 10; i++ { print("i = \(i)") }
for-in 也能用於陣列,寫法與 Objective-C 相同。由於 Swift 是強型別語言且支援型別推斷,for-in 中不必另外宣告型別。
var a: [Int] = [1, 2, 3, 4, 5]
for i in a {
print("i = \(i)")
}
// 輸出:i = 1 / i = 2 / i = 3 / i = 4 / i = 5
與 Objective-C 幾乎一樣,只是條件不需要小括號。
var a = 1
while a < 10 {
a++
print("a")
}
// 先判斷 a 是否小於 10,成立才進入迴圈,每輪再判斷一次,直到不成立
var b = 1
repeat { // Swift 中 do 換成了 repeat,作用相同
b++
print("b")
} while b < 10
// 先執行一遍區塊內容,再做條件判斷
break 可強制跳出迴圈,continue 結束當前這一輪、進入下一輪。
var i: Int = 0
repeat {
i += 1
if i >= 10 {
break // 跳出迴圈,執行後續程式碼
}
if i % 2 == 0 {
continue // 結束這一輪,進入下一輪
}
print("i = \(i)")
} while true // 死循環
print("end")
// 輸出:i = 1 / i = 3 / i = 5 / i = 7 / i = 9 / end
在 Swift 中,基本資料類型也各自帶有方法,可以透過方法操作資料。例如 Int.max 能取得 Int 可儲存的最大值,a.hashValue 能得到整數 a 的哈希值。
Swift 是強型別語言:任何型別的值都不能隱式轉換成另一型別,需要轉換時得明確呼叫轉換初始化器,例如 Int(b)。
| 名稱 | 說明 |
|---|---|
| 整型 | 包含 Int、Int8、Int16、Int32、Int64 等有符號整型,以及 UInt8、UInt16、UInt32、UInt64 等無符號整型 |
| 浮點型 | Float 與 Double,預設推斷為 Double |
| 布爾型 | true 與 false,放棄了 Objective-C 的 YES / NO;不支援隱式轉換,0 與非 0 不再代表 false 與 true |
| 字串 | String,類似腳本語言,可直接串接與追加 |
| 陣列 | 不同於 Objective-C 陣列只能裝物件,Swift 陣列可包含所有型別 |
| 字典 | 同樣可包含所有型別,key 也可以是任何基本資料類型 |
只能儲存整數,預設推斷為 Int。
var a = 10 // a 是 Int Int.max // 可取到的最大值 Int.min // 可取到的最小值
預設推斷為 Double。Float 為 32 位,Double 為 64 位,與設備架構無關。
var f: Float = 2.2
在 Swift 中,0 不代表 false,非 0 也不代表 true,nil 也不等於 false。所有值都必須型別明確、無法隱式轉換,所以 if (1) 這種寫法不復存在。
Swift 新增了 String 型別(使用 Cocoa 時 NSString 依然可用)。String 是 Character 值的集合,每個 Character 代表一個 Unicode 字元。由於每個字元佔用的空間不同,無法用「記憶體大小」推算字串長度。
// 建立
var str: String = "asA中??"
// 取得長度
print(str.characters.count) // 5
// 串接
let newStr = str + "123"
print("拼接後的字串:\(newStr)") // asA中??123
// 追加
str += "456"
print(str) // asA中??456
// 取首字元
print(str.substringToIndex(str.startIndex.advancedBy(1))) // a
// 取尾字元
print(str.substringFromIndex(str.endIndex.advancedBy(-1))) // 6
// 取中間區間
let start = str.startIndex.advancedBy(1)
let end = str.endIndex.advancedBy(-1)
print(str[start...end]) // sA中??456
// 取得子字串位置
let r: Range? = str.rangeOfString("sA")
print(r!) // 1..<3
// 刪除區間
str.removeRange(r!)
print(str) // a中??456
// 遍歷字元
for c in str.characters {
print(String(c)) // a, 中, ?, 4, 5, 6
}
// 比較
let x = "a"
let y = "b"
print(x == y) // false
String 的用法與 NSString 差異不小:語法更簡潔,更貼近一般數值類型的操作習慣;支援區間符號 ...,取子字串很方便;串接與追加直接用 + 與 += 即可;比較與遍歷也相當直觀。
Swift 陣列有兩個與 Objective-C 不同的重點:可以儲存任何型別(包含 Int、String 等基本型別);同一個陣列只能放相同型別的元素,這確保了取出來的資料型別一致,避免了不少錯誤。
// 建立
var array1: [String] = ["a", "b", "1"]
var array2: [String]
var array3: Array<Int> = [1, 2, 3, 5]
// 取得數量
array1.count // 3
// 遍歷
for a in array1 {
print(a) // a, b, 1
}
// 新增
array1.append("c") // ["a", "b", "1", "c"]
// 刪除
array1.removeAtIndex(1) // ["a", "1", "c"]
// 取值
print(array1[0]) // a
// 取區間
print(array1[0...1]) // ["a", "1"]
// 插入
array1.insert("z", atIndex: 0) // ["z", "a", "1", "c"]
// 判斷是否為空
print(array1.isEmpty) // false
要注意「值型別」與「參考型別」的差別。如果陣列存的是基本型別、結構或列舉,Swift 會把資料複製進陣列,改動外部變數或陣列內的元素都不會互相影響:
var a = 1, b = 2, c = 3, d = 4 let all: Array<Int> = [a, b, c, d] a = 11 print(all[0]) // a 變了,但陣列不受影響,輸出 1
如果是類別物件,則是引用進陣列,任何一方的改變都會反映到另一方:
var a: UIView = UIView() let all = [a] print(all[0].tag) // 0 a.tag = 1 // 改 a.tag,陣列第一個元素的 tag 也跟著變 print(all[0].tag]) // 1
在 Swift 中,任何遵循 Hashable 協議的型別都能當作字典的 key,而所有基本型別都遵循 Hashable,所以它們都能勝任;Objective-C 中則只有 NSString 類別可以當 key。字典可儲存的內容與陣列一樣,任何型別都行,不像 Objective-C 只能存 NSObject。
// 建立
var dic = ["a": 1]
var dic1: Dictionary<String, Int> = [:]
var dic2: [String: Int] = Dictionary()
// 取得元素數量
print(dic.count)
// 遍歷
for (str, number) in dic {
print(str + " " + String(number))
}
// 新增元素
dic["b"] = 2
// 刪除元素
dic.removeValueForKey("a")
// 修改元素
dic["b"] = 3
// 透過 key 取值
print(dic["b"]!)
注意:字典的 value 是 optional,取值時需要用 ! 強制解包。為了安全,每次強制解包前最好先判斷是否為空,或改用 if let 綁定。