iOS學習筆記47-Swift(七)泛型

1、Swift泛型介紹

泛型是爲Swift編程靈活性的一種語法，在函數、枚舉、結構體、類中都獲得充分的應用，它的引入能夠起到佔位符的做用，當類型暫時不肯定的，只有等到調用函數時才能肯定具體類型的時候能夠引入泛型。
咱們以前實際上已經使用過泛型，例如：Swift的Array和Dictionary類型都是泛型集。

你能夠建立一個Int數組，也可建立一個String數組，或者甚至於能夠是任何其餘Swift的類型數據數組。一樣的，你也能夠建立存儲任何指定類型的字典(Dictionary)，並且這些類型能夠是沒有限制的。

咱們爲何要使用泛型呢？下面有個例子能夠簡單說明使用泛型的好處

//定義一個函數，要求追加數組數據到指定一個數組中 func appendIntToArray(src:[Int],inout dest:[Int]) { // 遍歷並加到數組後邊 for element in src{ dest.append(element) } } //使用copyIntArray添加整形數組數據 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) } } //使用copyStringArray添加字符串數組數據 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) //appendArray自動識別要添加的數組數據類型 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]

個人理解：泛型就是先佔坑，具體佔坑作什麼，隨你

2、Swift泛型使用

Swift泛型相關使用可分爲如下幾點：

1. 泛型函數
2. 泛型類型
3. 泛型約束
4. 泛型協議

1. 泛型函數，函數參數或返回值類型用泛型表示

//泛型函數定義式 func 函數名<泛型1,泛型2,…>(形參列表)->返回值類型 { //函數體... }

泛型函數使用實例

//定義一個泛型函數，把2個參數的值進行交換 func swapTwoValues<T>(inout valueOne: T, inout valueTwo: T) { let temporaryA = valueOne valueOne = valueTwo valueTwo = temporaryA } //交換2個整形變量 var oneInt = 3 var twoInt = 107 swapTwoValues(&oneInt, valueTwo: &twoInt) print("oneInt = \(oneInt), twoInt = \(twoInt)") //打印：oneInt = 107, twoInt = 3 //交換2個字符串變量 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]() //由於壓棧會修改實例值，須要加上mutationg關鍵字 mutating func push(item: T) { items.append(item) } //由於出棧會修改實例值，須要加上mutationg關鍵字 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)") print("出棧：\(stackOfStrings.pop())，棧中還剩：\(stackOfStrings.items)") print("出棧：\(stackOfStrings.pop())，棧中還剩：\(stackOfStrings.items)") /* 打印： 出棧：cuatro，棧中還剩：["uno", "dos", "tres"] 出棧：tres，棧中還剩：["uno", "dos"] 出棧：dos，棧中還剩：["uno"] */ //建立一個整形棧，棧裏面存的是整形 var stackOfInt = Stack<Int>() stackOfInt.push(12) stackOfInt.push(32) stackOfInt.push(45) stackOfInt.push(35) print("出棧：\(stackOfInt.pop())，棧中還剩：\(stackOfInt.items)") print("出棧：\(stackOfInt.pop())，棧中還剩：\(stackOfInt.items)") print("出棧：\(stackOfInt.pop())，棧中還剩：\(stackOfInt.items)") /* 打印： 出棧：35，棧中還剩：[12, 32, 45] 出棧：45，棧中還剩：[12, 32] 出棧：32，棧中還剩：[12] */

壓棧：

 

出棧：

 

3. 泛型約束，爲泛型類型添加約束

泛型約束大體分爲如下幾種：

1. 繼承約束，泛型類型必須是某個類的子類類型
2. 協議約束，泛型類型必須遵循某些協議
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 AnimalRunPint<T:Animal>(animal:T){ animal.run() //繼承了Animal類的子類都有run方法能夠調用 } AnimalRunPint(Dog()) AnimalRunPint(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) if let index = doubleIndex { print("在浮點型數組中尋找到9.3，尋找索引爲\(index)") } else { print("在浮點型數組中尋找不到9.3") } //在字符串數組中進行查找，String默認遵循了Equatable協議 let stringIndex = findIndex(["Mike", "Malcolm", "Andrea"], valueToFind: "Andrea") if let index = stringIndex { print("在字符串數組中尋找到Andrea，尋找索引爲\(index)") } else { print("在字符串數組中尋找不到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){//實現協議的push方法要求 store.append(item) } mutating func pop() -> T {//實現協議的pop方法要求 return store.removeLast() } } //建立Stack結構體，泛型類型爲String 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協議，並且C1和C2包含的泛型類型要一致 func pushItemOneToTwo<C1: Stackable, C2: Stackable where C1.ItemType == C2.ItemType>(inout stackOne: C1, inout stackTwo: C2) {//由於C1和C2都遵循了Stackable協議，纔有ItemType屬性能夠調用 let item = stackOne.pop() stackTwo.push(item) } //定義另一個結構體類型，一樣實現Stackable協議，實際上裏面的實現和Stack同樣 struct StackOther<T>: Stackable{ var store = [T]() mutating func push(item:T){//實現協議的push方法要求 store.append(item) } mutating func pop() -> T {//實現協議的pop方法要求 return store.removeLast() } } //建立StackOther結構體，泛型類型爲String 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"]