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

Swift 泛型完全解析:從佔位符到約束條件

編輯:iOS 開發綜合

一、Swift 泛型簡介

泛型是提升 Swift 程式碼靈活性的重要語法,廣泛應用於函式、列舉、結構體與類別之中。它的作用如同「佔位符」:當型別暫時無法確定、只有等到呼叫時才能決定具體型別的情況,就能靠泛型來解決。
其實我們早已用過泛型,例如 Swift 的 Array 與 Dictionary 都是泛型集合。

你可以建立一個 Int 陣列,也可以建立 String 陣列,甚至是任何其他 Swift 型別的陣列。同樣地,你也可以建立儲存任意指定型別的字典(Dictionary),而且這些型別幾乎沒有任何限制。

那麼,我們為什麼要用泛型呢?下面這個例子可以簡單說明它的好處:

 // 定義一個函式,將某陣列的資料追加到指定陣列中 func appendIntToArray(src: [Int], inout dest: [Int]) { for element in src { dest.append(element) } } // 使用它來添加整數陣列 var arr = [2, 5] appendIntToArray([12, 9], dest: &arr) print(arr) // [2, 5, 12, 9] // 那如果要添加字串呢?只好再重寫一個函式 func appendStringToArray(src: [String], inout dest: [String]) { for element in src { dest.append(element) } } var strArr = ["oc", "swift"] appendStringToArray(["php", "C#"], dest: &strArr) print(strArr) // ["oc", "swift", "php", "C#"] // 如果還要支援其他型別呢?難道每個型別都得寫一個對應函式?那樣太繁複了! // 這時候就需要泛型登場 // 定義泛型函式,在函式名後加上 <T>,T 是型別佔位符,可代表任何型別 func appendArray<T>(src: [T], inout dest: [T]) { for element in src { dest.append(element) } } // 如此強大,隨心所欲地使用 var arr2 = [5, 8] appendArray([9, 58], dest: &arr2) print(arr2) // [5, 8, 9, 58] var strArr2 = ["renhairui", "hello"] appendArray(["nihao", "helloworld"], dest: &strArr2) print(strArr2) // ["renhairui", "hello", "nihao", "helloworld"] var doubleArr = [1.2, 3.4] appendArray([6.5, 1.0], dest: &doubleArr) print(doubleArr) // [1.2, 3.4, 6.5, 1.0]

我的理解:泛型就是先「佔坑」,至於這個坑要拿來做什麼,隨你決定。

二、Swift 泛型的使用

Swift 泛型的相關用法大致可分為以下幾類:

泛型函式、泛型型別、泛型約束、泛型協議。

1. 泛型函式:函式的參數或回傳值型別以泛型表示
 // 泛型函式定義式 func 函式名<泛型1, 泛型2, …>(參數列表) -> 回傳值型別 { // 函式主體 }
泛型函式使用實例
 // 定義一個泛型函式,交換兩個參數的值 func swapTwoValues<T>(inout valueOne: T, inout valueTwo: T) { let temporaryA = valueOne valueOne = valueTwo valueTwo = temporaryA } // 交換兩個整數變數 var oneInt = 3 var twoInt = 107 swapTwoValues(&oneInt, valueTwo: &twoInt) print("oneInt = \(oneInt), twoInt = \(twoInt)") // oneInt = 107, twoInt = 3 // 交換兩個字串變數 var oneStr = "hello" var twoStr = "world" swapTwoValues(&oneStr, valueTwo: &twoStr) print("oneStr = \(oneStr), twoStr = \(twoStr)") // oneStr = world, twoStr = hello
2. 泛型型別:在定義型別時使用泛型

用法與泛型函式類似,就是在型別名稱後加上 <泛型1, 泛型2, …>,接著在型別內部直接使用泛型即可。

 // 定義一個泛型結構體,用於壓棧與出棧 struct Stack<T> { // 以陣列作為儲存形式,元素型別為泛型 var items = [T]() // 壓棧會修改實例值,需加上 mutating 關鍵字 mutating func push(item: T) { items.append(item) } // 出棧同樣會修改實例值,需加上 mutating 關鍵字 mutating func pop() -> T { return items.removeLast() } } // 建立一個字串堆疊 var stackOfStrings = Stack<String>() stackOfStrings.push("uno") stackOfStrings.push("dos") stackOfStrings.push("tres") stackOfStrings.push("cuatro") print("出棧:\(stackOfStrings.pop()),棧中還剩:\(stackOfStrings.items)") /* 出棧:cuatro,棧中還剩:["uno", "dos", "tres"] ... */ // 建立一個整數堆疊 var stackOfInt = Stack<Int>() stackOfInt.push(12) stackOfInt.push(32) stackOfInt.push(45) stackOfInt.push(35) print("出棧:\(stackOfInt.pop()),棧中還剩:\(stackOfInt.items)") /* 出棧:35,棧中還剩:[12, 32, 45] ... */
壓棧:

出棧:

3. 泛型約束:為泛型型別加上限制
泛型約束大致分為以下幾種:

繼承約束(泛型型別必須是某個類別的子類)、協議約束(泛型型別必須遵循某些協議)、條件約束(泛型型別必須滿足某種條件)。

約束的大致使用格式
 // 繼承約束 func 函式名<泛型: 父類>(參數列表) -> 回傳值 { // 泛型型別是某類別的子類 } // 協議約束 func 函式名<泛型: 協議>(參數列表) -> 回傳值 { // 泛型型別遵循某些協議 } // 條件約束 func 函式名<泛型1, 泛型2 where 條件>(參數列表) -> 回傳值 { // 泛型型別滿足某些條件 }
繼承約束使用範例
 // 定義父類:動物類 class Animal { // 動物都會跑 func run() { print("Animal run") } } // 狗類繼承動物類 class Dog: Animal { override func run() { print("Dog run") } } // 貓類繼承動物類 class Cat: Animal { override func run() { print("Cat run") } } // 泛型函式要求型別必須繼承 Animal func AnimalRunPrint<T: Animal>(animal: T) { animal.run() // 繼承自 Animal 的子類都擁有 run 方法 } AnimalRunPrint(Dog()) AnimalRunPrint(Cat()) /* 列印: Dog run Cat run */
協議約束使用範例

Swift 標準函式庫定義了一個 Equatable 協議,任何遵循它的型別都必須實作等號(==)與不等號(!=)運算子,以比較該型別的兩個值。所有 Swift 標準型別都自動支援 Equatable 協議。

 // 泛型函式加上協議約束,型別必須遵循 Equatable func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? { var index = 0 for value in array { if value == valueToFind { // 遵循 Equatable 才能進行相等比較 return index } else { index++ } } return nil } // 在浮點陣列中查找,Double 預設遵循 Equatable let doubleIndex = findIndex([3.14159, 0.1, 0.25], valueToFind: 9.3) // 在字串陣列中查找,String 預設遵循 Equatable let stringIndex = findIndex(["Mike", "Malcolm", "Andrea"], valueToFind: "Andrea") /* 列印: 在浮點型陣列中尋找不到 9.3 在字串陣列中找到 Andrea,索引為 2 */
4. 泛型協議與條件約束

上面的 Equatable 其實不是普通協議,而是泛型協議。假設某泛型型別必須遵循一個協議,此時就需要在協議中引入一個「關聯型別」來解決問題。

 // 定義泛型協議,泛型以關聯型別的形式使用 protocol Stackable { // 使用 typealias 宣告關聯型別 typealias ItemType mutating func push(item: ItemType) mutating func pop() -> ItemType } struct Stack<T>: Stackable { var store = [T]() mutating func push(item: T) { store.append(item) } mutating func pop() -> T { return store.removeLast() } } var stackOne = Stack<String>() stackOne.push("hello") stackOne.push("swift") stackOne.push("world") let t = stackOne.pop() print("t = \(t)") // t = world // 條件約束:C1 與 C2 都須遵循 Stackable,且泛型型別一致 func pushItemOneToTwo<C1: Stackable, C2: Stackable where C1.ItemType == C2.ItemType>(inout stackOne: C1, inout stackTwo: C2) { // 因為都遵循 Stackable,才有 ItemType 可呼叫 let item = stackOne.pop() stackTwo.push(item) } // 另一個同樣實作 Stackable 的結構體 struct StackOther<T>: Stackable { var store = [T]() mutating func push(item: T) { store.append(item) } mutating func pop() -> T { return store.removeLast() } } var stackTwo = StackOther<String>() stackTwo.push("where") // stackOne 與 stackTwo 型別不同,但泛型型別相同且都遵循 Stackable pushItemOneToTwo(&stackOne, stackTwo: &stackTwo) print("stackOne = \(stackOne.store), stackTwo = \(stackTwo.store)") // stackOne = ["hello"], stackTwo = ["where", "swift"]
  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved