一、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是個類型占用符，可以表示任何類型
func appendArray(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]

我的理解：泛型就是先占坑，具體占坑做什麼，隨你

二、Swift泛型使用

Swift泛型相關使用可分為以下幾點：

泛型函數 泛型類型 泛型約束 泛型協議

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

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

泛型函數使用實例

//定義一個泛型函數，把2個參數的值進行交換
func swapTwoValues(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 {
    //棧在這裡是個數組存儲形式，數組中存儲的數據類型是泛型類型
    var items = [T]()
    //因為壓棧會修改實例值，需要加上mutationg關鍵字
    mutating func push(item: T) {
        items.append(item)
    }
    //因為出棧會修改實例值，需要加上mutationg關鍵字
    mutating func pop() -> T {
        return items.removeLast()
    }
}
//創建一個字符串棧，棧裡面存的是字符串
var stackOfStrings = Stack()
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()
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. 泛型約束，為泛型類型添加約束

泛型約束大致分為以下幾種：

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

約束的大概使用格式

//繼承約束使用格式
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(animal:T){
    animal.run() //繼承了Animal類的子類都有run方法可以調用
}
AnimalRunPint(Dog())
AnimalRunPint(Cat())
/* 打印：
Dog run
Cat run
*/

協議約束使用范例

Swift標准庫中定義了一個Equatable協議，該協議要求任何遵循的類型實現等式符(==)和不等符(!=)對任何兩個該類型進行比較。所有的Swift標准類型自動支持Equatable協議。

//定義泛型函數，為泛型添加協議約束，泛型類型必須遵循Equatable協議
func findIndex(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: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()
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(inout stackOne: C1, inout stackTwo: C2) 
{//因為C1和C2都遵循了Stackable協議，才有ItemType屬性可以調用
    let item = stackOne.pop()
    stackTwo.push(item)
}
//定義另外一個結構體類型，同樣實現Stackable協議，實際上裡面的實現和Stack一樣
struct StackOther: 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()
stackTwo.push("where")
//雖然stackOne和stackTwo類型不一樣，但泛型類型一樣，也同樣遵循了Stackable協議
pushItemOneToTwo(&stackOne, stackTwo: &stackTwo )
print("stackOne = \(stackOne.store), stackTwo = \(stackTwo.store)")
//打印：stackOne = ["hello"], stackTwo = ["where", "swift"]