Swift泛型介绍

泛型是为Swift编程灵活性的一种语法，在函数、枚举、结构体、类中都得到充分的应用，它的引入可以起到占位符的作用，当类型暂时不确定的，只有等到调用函数时才能确定具体类型的时候可以引入泛型。
我们之前实际上已经使用过泛型，例如：Swift的Array和Dictionary类型都是泛型集。

你可以创建一个Int数组，也可创建一个String数组，或者甚至于可以是任何其他Swift的类型数据数组。同样的，你也可以创建存储任何指定类型的字典(Dictionary)，而且这些类型可以是没有限制的。

我们为什么要使用泛型呢？下面有个例子可以简单说明使用泛型的好处

// 定义一个函数,要求追加数组数据到指定一个数组中
func appendIntToArray(src:[Int],inout dest:[Int]) {
    // 遍历并加到数组后边
    for element in src {
        dest.append(element)
    }
}

// 使用appendIntToArray添加整形数组数据
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)

// 如果有需要你实现添加其他类型呢？
// 是不是每个类型都需要写一个对应的函数去实现,那这样就太复杂了!这时候我们就需要使用泛型
// 定义泛型函数,在普通函数名后面加上<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]

我的理解：泛型就是先占坑，具体占坑做什么，随你

Swift泛型使用

Swift泛型相关使用可分为以下几点：
泛型函数
泛型类型
泛型约束
泛型协议

泛型函数，函数参数或返回值类型用泛型表示

// 泛型函数定义式
func 函数名<泛型1,泛型2,…>(形参列表)->返回值类型
{
// 函数体...
}

泛型函数使用实例

// 定义一个泛型函数,把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

泛型类型，在定义类型时使用泛型

使用也和泛型函数差不多，就是在类型名后面加上<泛型1,泛型2,…>，然后在类型里面直接使用泛型即可

通常在泛型函数中，Swift 允许你定义你自己的泛型类型。这些自定义类、结构体和枚举作用于任何类型，如同Array和Dictionary的用法。
这部分向你展示如何写一个泛型集类型--Stack（栈）。一个栈是一系列值域的集合，和Array（数组）类似，但其是一个比 Swift 的Array类型更多限制的集合。一个数组可以允许其里面任何位置的插入/删除操作，而栈，只允许在集合的末端添加新的项（如同push一个新值进栈）。同样的一个栈也只能从末端移除项（如同pop一个值出栈）。

注意栈的概念已被UINavigationController类使用来模拟视图控制器的导航结构。
你通过调用UINavigationController的pushViewController(:animated:)方法来为导航栈添加（add）新的视图控制器；
而通过popViewControllerAnimated(:)的方法来从导航栈中移除（pop）某个视图控制器。
每当你需要一个严格的后进先出方式来管理集合，堆栈都是最实用的模型。

下图展示了一个栈的压栈(push)/出栈(pop)的行为：

现在有三个值在栈中；
第四个值“pushed”到栈的顶部；
现在有四个值在栈中，最近的那个在顶部；
栈中最顶部的那个项被移除，或称之为“popped”；
移除掉一个值后，现在栈又重新只有三个值。

这里展示了如何写一个非泛型版本的栈,Int值型的栈:

// 这里展示了如何写一个非泛型版本的栈,Int值型的栈:
struct IntStack {
    var items = [Int]()
    mutating func push(item:Int) {
        items.append(item)
    }
    
    mutating func pop() -> Int {
        return items.removeLast()
    }

}

这个结构体在栈中使用一个Array性质的items存储值。Stack提供两个方法：push和pop，从栈中压进一个值和移除一个值。这些方法标记为可变的，因为它们需要修改（或转换）结构体的items数组。
上面所展现的IntStack类型只能用于Int值，不过，其对于定义一个泛型Stack类（可以处理任何类型值的栈）是非常有用的。

这里是一个相同代码的泛型版本

// 这里是一个相同代码的泛型版本:
struct Stack<T> {
    var items = [T]()
    mutating func push(item:T) {
        items.append(item)
    }
    
    mutating func pop() -> T {
        return items.removeLast()
    }
}

注意到Stack的泛型版本基本上和非泛型版本相同，但是泛型版本的占位类型参数为T代替了实际Int类型。这种类型参数包含在一对尖括号里（<T>），紧随在结构体名字后面。
T定义了一个名为“某种类型T”的节点提供给后来用。这种将来类型可以在结构体的定义里任何地方表示为“T”。在这种情况下，T在如下三个地方被用作节点：

创建一个名为items的属性，使用空的T类型值数组对其进行初始化；
指定一个包含一个参数名为item的push(_:)方法，该参数必须是T类型；
指定一个pop方法的返回值，该返回值将是一个T类型值。

由于Stack是泛型类型，所以在 Swift 中其可以用来创建任何有效类型的栈，这种方式如同Array和Dictionary。
你可以通过在尖括号里写出栈中需要存储的数据类型来创建并初始化一个Stack实例。比如，要创建一个strings的栈，你可以写成Stack<String>()：

var stackOfStrings = Stack<String>()
stackOfStrings.push("uno")
stackOfStrings.push("dos")
stackOfStrings.push("tres")
stackOfStrings.push("cuatro")
// 现在栈已经有4个string了

下图将展示stackOfStrings如何push这四个值进栈的过程：

从栈中pop并移除值"cuatro"

let fromTop = stackOfStrings.pop()
// fromTheTop 等于 "cuatro", 现在栈中还有3个string

下图展示了如何从栈中pop一个值的过程：

扩展一个泛型类型

当你扩展一个泛型类型的时候，你并不需要在扩展的定义中提供类型参数列表。更加方便的是，原始类型定义中声明的类型参数列表在扩展里是可以使用的，并且这些来自原始类型中的参数名称会被用作原始定义中类型参数的引用。

下面的例子扩展了泛型Stack类型，为其添加了一个名为topItem的只读计算属性，它将会返回当前栈顶端的元素而不会将其从栈中移除。

extension Stack {
    var topItem:T? {
        return items.isEmpty ? nil :items[items.count - 1]
    }
}

if let topItem = stackOfStrings.topItem {
    print("The top item on the stack is (topItem).")
}
// 输出 "The top item on the stack is tres."

泛型约束，为泛型类型添加约束

泛型约束大致分为以下几种：
继承约束，泛型类型必须是某个类的子类类型
协议约束，泛型类型必须遵循某些协议
条件约束，泛型类型必须满足某种条件
约束的大概使用格式

// 继承约束使用格式
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())   // Dog run
AnimalRunPint(Cat())   // 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
*/

泛型协议和条件约束

上面的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"]