您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發綜合

Swift 2.0 基本語法整理:流程控制與常用資料類型

編輯:iOS 開發綜合

基本語法速查

名稱作用
print控制台輸出
var宣告一個變數
let宣告一個常量
if…else…條件判斷
switch…case…分支判斷
for循環
while先判斷後循環

print

向控制台輸出 log。

print("hello world")        // 輸出純字串
print("1 + \(1) = ?")       // 字串插值:括號內可放任意內容,輸出 1 + 1 = ?
var a: Float = 2.1
print("1 + \(a)")           // 字串 + 變數,輸出 1 + 2.1

var

宣告一個變數,代表可以修改的資料,可重複賦值。

var a: Int = 0
a = 100                     // 可以再次賦值
var b: NSObject = NSObject()

let

宣告一個不可變的常量,只能賦值一次。

let a: Int = 0
a = 100                     // 這行會報錯,不可再次賦值

if…else

條件判斷。與 Objective-C 相比主要有三點差異:

1. 條件不一定要放在小括號中;
2. 條件必須是明確的 true 或 false——0 與非 0 不會隱式轉為布林值,nil 與非 nil 同樣不會;
3. 執行敘述必須包在大括號中。

let a: Int = 0
if a == 0 {
    a = 100                   // 條件成立時執行
} else {
    a = 50                    // 條件不成立時執行
}

switch

關鍵字說明:

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 本身。

for

與 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

while

與 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 綁定。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved