Swift之泛型

发表于 2016-11-04 分类于 Swift

泛型就是适用于任意类型、灵活可重用的函数及类型。泛型可以避免代码的重复。比如Swift的数组、字典、可选类型。

泛型数据结构

比如自定义一个名stack（栈）函数：

struct IntStack{
    var items = [Int]()
    mutating func push(_ item: Int){
        items.append(item)
    }
    mutating func pop()->Int{
        return items.removeLast()
    }
}

这个结构体在栈中使用一个名为 items 的 Array 属性来存储值。Stack 提供了两个方法：push(_:) 和 pop()，用来向栈中压入值以及从栈中移除值。这些方法被标记为 mutating，因为它们需要修改结构体的 items 数组。

这个IntStack结构体只适用于Int类型。下面把这个结构体改成适合任意类型的泛型：

struct Stack<Element>{
    var items = [Element]()
    mutating func push(_ item: Element){
        item.append(item)
    }
    mutating func pop() -> Element{
        return items.removeLast()
    }
}

Element 为待提供的类型定义了一个占位名。这种待提供的类型可以在结构体的定义中通过 Element 来引用。

var stackStrings = Stack<String>()
stackStrings.push("name")
stackStrings.push("age")
let fromtheTop = stackStrings.pop()

泛型函数和方法

比如实现一个交换函数：

func swapTwoInts(_ a: inout Int, _ b: inout Int){
    let temp = a
    a = b
    b = temp
}

var someInt = 3
var anotherInt = 5
swapTwoInts(&someInt, &anotherInt)

把上面的函数改写成泛型函数：

func swapTwoValues<T>(_ a: inout T, _ b: inout T){
    let temp = a
    a = b
    b = temp
}

这个泛型函数使用了占位类型名（在这里用字母 T 来表示）来代替实际类型名（例如 Int、String 或 Double）。占位类型名没有指明 T 必须是什么类型，只有 swapTwoValues(_:_:) 函数在调用时，才能根据所传入的实际类型决定 T 所代表的类型。T也被称为类型参数。

另外一个不同之处在于这个泛型函数名（swapTwoValues(_:_:)）后面跟着占位类型名（T），并用尖括号括起来（<T>）。这个尖括号告诉 Swift 那个 T 是 swapTwoValues(_:_:) 函数定义内的一个占位类型名，因此 Swift 不会去查找名为 T 的实际类型。

如果泛型函数需要多个类型参数，将他们都写在尖括号中，用逗号分开。

类型约束

虽然泛型类型和泛型函数可以作用于任何类型，但有时需要给泛型类型或泛型函数中的类型添加一个特定的类型约束。类型约束可以指定一个类型参数必须继承自指定类，或者符合一个特定的协议或协议组合。

Swift 的 Dictionary 类型对字典的键的类型做了些限制。在字典的描述中，字典的键的类型必须是可哈希（hashable）的。也就是说，必须有一种方法能够唯一地表示它。Dictionary 的键之所以要是可哈希的，是为了便于检查字典是否已经包含某个特定键的值。若没有这个要求，Dictionary 将无法判断是否可以插入或者替换某个指定键的值，也不能查找到已经存储在字典中的指定键的值。

一个类型约束被强制加到 Dictionary 的键类型上，要求其键类型必须符合 Hashable 协议，这是 Swift 标准库中定义的一个特定协议。所有的 Swift 基本类型（例如 String、Int、Double 和 Bool）默认都是可哈希的。

类型的约束语法

语法示例：

1
2
3

func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
    // 泛型函数的函数体部分
}

第一个类型参数 T，有一个要求 T 必须是 SomeClass 子类的类型约束；第二个类型参数 U，有一个要求 U 必须符合 SomeProtocol 协议的类型约束。

示例：

//普通函数
func findIndex(ofString valueToFind: String, in array: [String]) ->Int?{
    for (index, value) in array.enumerated() {
        if value == valueToFind {
            return index
        }
    }
    return nil
}

//泛型函数
func findIndex<T: Equatable>(of valueToFind: T, in array: [T]) ->Int?{
    for (index, value) in array.enumerated() {
        if value == valueToFind {
            return index
        }
    }
    return nil
}

上面的T之所以需要遵守Equatable协议的原因：

在相等性检查上，即 “if value == valueToFind“。不是所有的 Swift 类型都可以用等式符（==）进行比较。比如说，如果你创建一个自定义的类或结构体来表示一个复杂的数据模型，那么 Swift 无法猜到对于这个类或结构体而言“相等”意味着什么。正因如此，这部分代码无法保证适用于每个可能的类型 T，当你试图编译这部分代码时会出现相应的错误。

Swift 标准库中定义了一个 Equatable 协议，该协议要求任何遵循该协议的类型必须实现等式符（==）及不等符(!=)，从而能对该类型的任意两个值进行比较。所有的 Swift 标准类型自动支持 Equatable 协议。

关联类型协议

协议不能是泛型，但是协议支持类型的一个相关特性：关联类型。

关联类型为协议中的某个类型提供了一个占位名，它代表的实际类型在协议被采纳时才会被指定。使用associatedtype关键字来指定关联类型。

protocol Container{
    associatedtype ItemType
    mutating func append(_ item: ItemType)
    var count: Int{ get }
    subscript(i: Int) -> ItemType{ get }
}

Container 协议需要在不知道容器中元素的具体类型的情况下引用这种类型。Container 协议声明了一个关联类型 ItemType，写作 associatedtype ItemType。ItemType 是什么类型的别名由遵循该协议的类型来提供。

struct Stack<Element>: Container {
    // Stack<Element> 的原始实现部分
    var items = [Element]()
    mutating func push(_ item: Element) {
        items.append(item)
    }
    mutating func pop() -> Element {
        return items.removeLast()
    }
    // Container 协议的实现部分
    mutating func append(_ item: Element) {
        self.push(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Element {
        return items[i]
    }
}

通过扩展一个存在的类型来指定关联类型

形式：

1	extension Array: Container{}

定义了这个扩展后，你可以将任意 Array 当作 Container 来使用。