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

Swift 語言核心筆記(二):函數、閉包、類與屬性機制

編輯:iOS 開發綜合

本條目從函數出發,一路談到閉包、類、屬性、構造方法、下標腳本與繼承,並特別著墨於 Swift 與 Objective-C 在這些主題上的關鍵差異。

函數:參數名是設計的一部分

函數是完成獨立任務的程式碼區塊。Swift 的函數不僅能像 C 語言那樣作為參數與回傳值,還支援巢狀定義,並提供參數預設值、可變參數與輸入輸出參數等能力。

// 沒有回傳值時可省略箭頭,或寫成 Void、空元組 ()(Void 的本質就是空元組)
func sum(num1: Int, num2: Int) -> Int {
    return num1 + num2
}
sum(1, 2)

語法形式雖有差異,本質與其他語言並無不同。真正值得留意的是 Swift 明確區分了「局部參數名」(形式參數)與「外部參數名」,這在很大程度上照顧了 Objective-C 開發者的閱讀習慣。

/**
 * 函數參數名分為局部參數名與外部參數名
 */
func split(string a: String, seperator b: Character) -> [String] {
    return split(a, maxSplit: Int.max, allowEmptySlices: false, isSeparator: { $0 == b })
}

// 設定了外部參數名,呼叫時就必須帶上,可讀性大幅提升
split(string: "hello,world,!", seperator: ",")   // ["hello", "world", "!"]

// 在局部參數名前加 #,可讓外部參數名與局部參數名同名
func split2(#string: String, #seperator: Character) -> [String] {
    return split(string, maxSplit: Int.max, allowEmptySlices: false, isSeparator: { $0 == seperator })
}
split2(string: "hello,world,!", seperator: ",")

// 有預設值時,參數名預設同時作為外部參數名
func split3(#string: String, seperator: Character = ",") -> [String] {
    return split(string, maxSplit: Int.max, allowEmptySlices: false, isSeparator: { $0 == seperator })
}
split3(string: "hello,world,!", seperator: ",")     // ["hello", "world", "!"]
split3(string: "hello world !", seperator: " ")     // ["hello", "world", "!"]

// 用 _ 取消外部參數名
func split4(string: String, _ seperator: Character = ",") -> [String] {
    return split(string, maxSplit: Int.max, allowEmptySlices: false, isSeparator: { $0 == seperator })
}
split4("hello,world,!", ",")                        // ["hello", "world", "!"]

/**
 * 可變參數:一個函數最多一個,且必須是最後一個參數
 * strings 在函數內部是 [String],對外部則是不定個數的 String
 */
func joinStr(seperator: Character = ",", strings: String...) -> String {
    var result: String = ""
    for var i = 0; i < strings.count; i++ {
        if i != 0 {
            result.append(seperator)
        }
        result += strings[i]
    }
    return result
}
joinStr(seperator: " ", "hello", "world", "!")      // "hello world !"

/**
 * 函數參數預設是常量,無法直接修改;加上 var 可視為區域變數
 * 但此變數只在函數內部有效,函數結束即消失(C 語言的參數預設是變數)
 */
func sum2(var num1: Int, num2: Int) -> Int {
    num1 = num1 + num2
    return num1
}
sum2(1, 2)                                          // 3

/**
 * 輸入輸出參數:可在函數內部修改外部變數(呼叫時不可傳入常量或字面值)
 * 以下 swap 僅為示範,實務請直接使用 Swift 的全域 swap 函數
 */
func swap(inout a: Int, inout b: Int) {
    a = a + b
    b = a - b
    a = a - b
}
var a = 1, b = 2
swap(&a, &b)        // 呼叫時加上 &
print("a=\(a), b=\(b)")                            // a=2, b=1

函數本身也是一種類型,既能當參數也能當回傳值:

var sum3 = sum    // 型別推斷為 (Int, Int) -> Int,不同函數型別之間不能直接賦值
sum3(1, 2)          // 3

// 函數作為回傳值
func fn() -> (Int, Int) -> Int {
    // 巢狀函數
    func minus(a: Int, b: Int) -> Int {
        return a - b
    }
    return minus
}
var minus = fn()

// 函數作為參數
func caculate(num1: Int, num2: Int, fn: (Int, Int) -> Int) -> Int {
    return fn(num1, num2)
}
caculate(1, 2, sum)     // 3
caculate(1, 2, minus)   // -1

閉包:可以捕獲上下文的程式碼區塊

Swift 的閉包相當於 Objective-C 的 Block,也近似 C#、Java 的 lambda。它的核心特徵是能捕獲並保存上下文中的常量或變數引用——即使這些變數在原作用域中已銷毀,區塊內仍可存取。嚴格說,全域函數與巢狀函數也是閉包:前者不捕獲任何變數,後者則會捕獲所在函數的變數。但我們平常所說的閉包,多指沒有名稱的閉包表達式(匿名閉包),其形式為:

{ ( parameters ) -> returnType in
    statements
}

下面的例子展示閉包表達式如何被逐層簡化,也順帶體現了 Swift 語法的簡潔取向:

func sum(num1: Int, num2: Int) -> Int { return num1 + num2 }
func minus(num1: Int, num2: Int) -> Int { return num1 - num2 }
func caculate(num1: Int, num2: Int, fn: (Int, Int) -> Int) -> Int { return fn(num1, num2) }

var (a, b) = (1, 2)
caculate(a, b, sum)                 // 3
caculate(a, b, minus)               // -1

// 以閉包表達式取代具名函數
caculate(a, b, { (num1: Int, num2: Int) -> Int in
    return num1 - num2
})                                  // -1

// 依上下文推斷型別;單一表達式的閉包可省略 return
caculate(a, b, { num1, num2 in
    num1 - num2
})                                  // -1

// 使用參數名縮寫 $0...$n,並省略 in
caculate(a, b, { $0 - $1 })         // -1

若函數的最後一個參數是閉包,可以把它移到呼叫的括號之外,這種寫法稱為「尾隨閉包」;若它是唯一的參數,連括號都能省:

// 尾隨閉包
caculate(a, b) { $0 - $1 }          // -1

閉包之所以叫「閉包」,就在於它會把作用域內的常量或變數「閉合包裹」起來:

func add() -> () -> Int {
    var total = 0
    var step = 1
    func fn() -> Int {
        total += step
        return total
    }
    return fn
}

// fn 捕獲了 total 與 step
var a = add()
a()     // 1
a()     // 2 —— 說明 a 保存了 total 的副本,否則結果仍會是 1

var b = add()
b()     // 1 —— 說明 a 與 b 各自持有獨立的副本,否則結果會是 3

var c = b
c()     // 2 —— 說明閉包是參考型別(函數亦然),否則結果會是 1

Swift 會自動決定捕獲時採取值拷貝還是參考拷貝,被捕獲變數的記憶體管理也由 runtime 負責;當 a 不再被使用,fn 所捕獲的變數便會一併釋放。

類:引用型別的一等公民

// Swift 的類不必繼承任何基底類,此時它本身就是一個基底類
class Person {
    var name: String
    var height = 0.0

    // 若不自行撰寫構造方法,系統會自動提供無參數構造方法
    init(name: String) {
        self.name = name
    }

    func showMessage() {
        print("name=\(name), height=\(height)")
    }

    // 解構方法,類似 Objective-C 的 dealloc;沒有括號、沒有參數、無法直接呼叫
    deinit {
        print("deinit...")
    }
}

var p = Person(name: "Kenhin")
p.height = 172.0
p.showMessage()     // name=Kenhin, height=172.0

// 類是引用型別
var p2 = p
p2.name = "Kaoru"
print(p.name)       // Kaoru

if p === p2 {       // === 表示「等價」,指向同一個物件
    print("p === p2")
}

由此可歸納幾點:Swift 的類不必繼承基底類(這點與通常必須繼承 NSObject 的 Objective-C 不同);屬性的宣告形式近似其他語言的成員變數;未自訂構造方法時系統會補一個無參數版本;解構方法沒有括號與參數,也不能自行呼叫。

屬性:儲存屬性與計算屬性

Swift 的屬性分兩類:儲存屬性(可用於類與結構體)與計算屬性(可用於類、結構體與列舉)。Swift 並不強調「成員變數」這個概念。儲存屬性在概念與寫法上更像其他語言的成員變數,但多了讀寫控制、屬性監視與懶載入等能力。

class Account {
    var balance: Double = 0.0
}

class Person {
    var firstName: String
    var lastName: String
    let age: Int

    // 計算屬性:只實作 get 即為唯讀屬性
    var fullName: String {
        get {
            return firstName + "." + lastName
        }
        set {
            // newValue 代表即將賦入的新值,也可自訂名稱
            let array = split(newValue, maxSplit: Int.max,
                              allowEmptySlices: false, isSeparator: { $0 == "." })
            if array.count == 2 {
                firstName = array[0]
                lastName = array[1]
            }
        }
    }

    // 唯讀屬性可簡寫為:
    // var fullName: String { return firstName + "." + lastName }

    // 懶載入:首次存取時才計算初始值,型別不限於物件
    lazy var account = Account()

    init(firstName: String, lastName: String, age: Int) {
        self.firstName = firstName
        self.lastName = lastName
        self.age = age
    }

    func showMessage() {
        print("name=\(self.fullName)")
    }
}

var p = Person(firstName: "Kenshin", lastName: "Cui", age: 29)
p.fullName = "Kaoru.Sun"
p.account.balance = 10
p.showMessage()

幾項重點:

  • 計算屬性不直接儲存值,而是以 getter 提供取值、以 setter 間接改寫其他屬性。
  • lazy 屬性必須有初始值,且必須是變數(常量在構造完成前就已經定下值)。
  • 構造方法執行前,所有儲存屬性都必須有值——無論以 var 還是 let 宣告,這個值可以在宣告時指定,也可以在構造方法中指定。

計算屬性的變化可以直接寫在 setter 裡監視;儲存屬性則做不到,因為它沒有 setter。為此 Swift 另外提供了 willSet 與 didSet,通稱「屬性監視器」。

class Account {
    // 注意:設定預設值 0.0 時不會觸發監視器
    var balance: Double = 0.0 {
        willSet {
            // newValue 可自訂名稱;在監視器中存取屬性不會造成循環呼叫
            // 此處修改 balance 並不會生效
            print("willSet, newValue=\(newValue), value=\(self.balance)")
        }
        didSet {
            // oldValue 可自訂名稱;此處修改 balance 會成為最終結果
            print("didSet, oldValue=\(oldValue), value=\(self.balance)")
        }
    }
}

class Person {
    var firstName: String
    var lastName: String
    let age: Int

    var fullName: String {
        get {
            return firstName + "." + lastName
        }
        set {
            // 計算屬性的監視直接寫在 set 中即可
            let array = split(newValue, maxSplit: Int.max,
                              allowEmptySlices: false, isSeparator: { $0 == "." })
            if array.count == 2 {
                firstName = array[0]
                lastName = array[1]
            }
        }
    }

    lazy var account = Account()

    init(firstName: String, lastName: String, age: Int) {
        self.firstName = firstName
        self.lastName = lastName
        self.age = age
    }

    // 型別屬性
    static var skin: Array<String> {
        return ["yellow", "white", "black"]
    }
}

var p = Person(firstName: "Kenshin", lastName: "Cui", age: 29)
p.account.balance = 1.0
print("p.account.balance=\(p.account.balance)")     // 3.0(didSet 中的修改生效)
for color in Person.skin {
    print(color)
}

監視器的幾個規則:

  • willSet 與 didSet 預設帶有 newValue 與 oldValue 參數,名稱同樣可自訂。
  • 設定儲存屬性的預設值、以及在構造方法中賦值,都不會觸發監視器;只有在外部設定時才會觸發。
  • 在儲存屬性的監視器內可以直接存取該屬性;但在計算屬性的 get/set 中直接存取自身會造成循環呼叫。
  • 在 didSet 中修改屬性值會成為最終值,willSet 中則無法改動。

方法與構造方法

方法就是與特定型別關聯的函數。Objective-C 中函數必須是 C 函數、方法則必須是 Objective-C 方法;而在 Swift 裡,方法除了用於類,也能用於結構體與列舉。這裡著重看構造方法。

class Person {
    var name: String
    var height: Double
    var age = 0

    // 指定構造方法
    init(name: String, height: Double, age: Int) {
        self.name = name
        self.height = height
        self.age = age
    }

    // 便利構造方法:透過呼叫指定構造方法並提供預設值來簡化建立流程
    convenience init(name: String) {
        self.init(name: name, height: 0.0, age: 0)
    }

    func modifyInfoWithAge(age: Int, height: Double) {
        self.age = age
        self.height = height
    }

    // 型別方法
    class func showClassName() {
        print("Class name is \"Person\"")
    }

    deinit {
        print("deinit...")
    }
}

var p = Person(name: "kenshin")     // 透過便利構造方法建立

關於參數名的預設行為,函數與方法不同:函數只有帶預設值的參數同時是外部參數,其餘皆為局部參數;而方法(構造與解構方法除外)預設第一個參數是局部參數,從第二個參數起同時是局部與外部參數——這與 Objective-C 的呼叫風格頗為相似。此外,構造方法的所有參數預設同時是外部與局部參數。

構造方法分兩類:指定構造方法是主力,負責把全部儲存屬性初始化完成;便利構造方法是輔助,透過呼叫指定構造方法並提供預設值來減少重複程式碼。每個類至少要有一個指定構造方法。

下標腳本

下標腳本是存取集合元素的快捷語法,例如 a[0]、a[1]。它以 subscript 關鍵字定義,宣告形式像方法,讀寫實作則像屬性。

class Record {
    var store: [String: String]

    init(data: [String: String]) {
        self.store = data
    }

    // 以索引存取(也可只實作 getter 做成唯讀)
    subscript(index: Int) -> String {
        get {
            let key = sorted(Array(self.store.keys))[index]
            return self.store[key]!
        }
        set {
            let key = sorted(Array(self.store.keys))[index]
            self.store[key] = newValue
        }
    }

    // 下標腳本重載:以鍵存取
    subscript(key: String) -> String {
        get {
            return store[key]!
        }
        set {
            store[key] = newValue
        }
    }
}

var r = Record(data: ["name": "kenshin", "sex": "male"])
print("r[0]=\(r[0])")       // r[0]=kenshin
r["sex"] = "female"
print(r[1])                 // female

繼承

與 Objective-C 相同,Swift 也是單繼承(可實作多個協議,協議寫在後面)。子類可以呼叫父類的屬性與方法、覆寫方法、加上屬性監視器,甚至把唯讀屬性覆寫成可讀寫。

class Person {
    var firstName: String, lastName: String
    var age: Int = 0

    var fullName: String {
        get {
            return firstName + " " + lastName
        }
    }

    init(firstName: String, lastName: String) {
        self.firstName = firstName
        self.lastName = lastName
    }

    func showMessage() {
        print("name=\(fullName), age=\(age)")
    }

    // final 宣告後子類無法覆寫
    final func sayHello() {
        print("hello world.")
    }
}

class Student: Person {
    // 覆寫屬性監視器
    override var firstName: String {
        willSet {
            print("oldValue=\(firstName)")
        }
        didSet {
            print("newValue=\(firstName)")
        }
    }

    var score: Double

    // 子類的指定構造方法必須呼叫父類構造方法,
    // 且必須在子類儲存屬性初始化之後
    init(firstName: String, lastName: String, score: Double) {
        self.score = score
        super.init(firstName: firstName, lastName: lastName)
    }

    convenience init() {
        self.init(firstName: "", lastName: "", score: 0)
    }

    // 把唯讀屬性覆寫為可讀寫
    override var fullName: String {
        get {
            return super.fullName
        }
        set {
            let array = split(newValue, maxSplit: Int.max,
                              allowEmptySlices: false, isSeparator: { $0 == "." })
            if array.count == 2 {
                firstName = array[0]
                lastName = array[1]
            }
        }
    }

    override func showMessage() {
        print("name=\(fullName), age=\(age), score=\(score)")
    }
}

var p = Student()
p.firstName = "kenshin"

Objective-C 的 init 其實並不安全:無法保證只被呼叫一次,而且在 init 中存取屬性也可能出問題,這些都只能依靠文件約定,編譯期發現不了,出錯偵測是被動的。Swift 給構造方法加了硬性規定——構造方法執行完成前,必須保證所有儲存屬性都有值;這條規則在整個繼承鏈上都必須成立,於是衍生出以下約束:

  • 子類的指定構造方法必須呼叫父類構造方法,且呼叫必須發生在子類儲存屬性初始化之後;指定構造方法不能呼叫同一類中的其他指定構造方法。
  • 便利構造方法必須呼叫同一類中的其他指定構造方法(指定或便利皆可),不能直接呼叫父類構造方法,以確保最終仍由指定構造方法收尾。
  • 若父類只有一個無參數構造方法(不論是否為便利構造方法),子類會自動呼叫它,此時無須手動撰寫。
  • 常量屬性必須在宣告時給定初始值,或在當前類的構造方法中初始化,不能在子類的構造方法中初始化。

註:本文範例採用早期 Swift 語法(如 println、var 參數、Array<String>),用以保留原始教學脈絡;實際開發請對照當前 Swift 版本調整。

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