Swift 3 泛型

Swift 提供的泛型可以让我们写出灵活且可重用的函数和类型

Swift 中泛型的使用

Swift 标准库是通过泛型代码构建出来的

Swift 的数组和字典类型都是泛型集

我们可以创建一个 Int 数组，也可创建一个 String 数组，或者甚至于可以是任何其他 Swift 的类型数据数组

下面的代码是一个非泛型函数 exchange 用来交换两个 Int 值

  1. import Cocoa
  3. // 定义一个交换两个变量的函数
  4. func swapTwoInts(_ a: inout Int, _ b: inout Int)
  5. {
  6.     let temporaryA = a
  7.     a = b
  8.     b = temporaryA
  9. }
  11. var numb1 = 100
  12. var numb2 = 200
  14. print("交换前数据: \(numb1) 和 \(numb2)")
  15. swapTwoInts(&numb1, &numb2)
  16. print("交换后数据: \(numb1) 和 \(numb2)")

编译运行以上 Swift 范例，输出结果为

  1. $ swift main.swift
  2. 交换前数据: 100 和 200
  3. 交换后数据: 200 和 100

函数 swapTwoInts 只能交换整数 Int 类型的变量

如果想要交换两个 String 值或者 Double 值，就得重新写个对应的函数

  1. import Cocoa
  3. // 交换两个字符串变量的值
  5. func swapTwoStrings(_ a: inout String, _ b: inout String)
  6. {
  7.     let temporaryA = a
  8.     a = b
  9.     b = temporaryA
  10. }
  12. // 交换两个 Double 变量的值
  14. func swapTwoDoubles(_ a: inout Double, _ b: inout Double)
  15. {
  16.     let temporaryA = a
  17.     a = b
  18.     b = temporaryA
  19. }

这三个函数从代码上来看，它们功能代码是相同的，只是类型上不一样

像这样的情况，我们可以使用泛型，从而避免重复编写代码

泛型

泛型使用了占位类型名（在这里用字母 T 来表示）来代替实际类型名（例如 Int、String 或 Double）

  1. func swapTwoValues<T>(_ a: inout T, _ b: inout T)

swapTwoValues 后面跟着占位类型名（T），并用尖括号括起来（<T>）

这个尖括号告诉 Swift 那个 T 是 swapTwoValues(::) 函数定义内的一个占位类型名

因此 Swift 不会去查找名为 T 的实际类型

下面的代码使用一个泛型函数 exchange 用来交换两个 Int 和 String 值

  1. import Cocoa
  3. // 定义一个交换两个变量的函数
  5. func swapTwoValues<T>(_ a: inout T, _ b: inout T)
  6. {
  7.     let temporaryA = a
  8.     a = b
  9.     b = temporaryA
  10. }
  12. var numb1 = 100
  13. var numb2 = 200
  15. print("交换前数据:  \(numb1) 和 \(numb2)")
  16. swapTwoValues(&numb1, &numb2)
  17. print("交换后数据: \(numb1) 和 \(numb2)")
  19. var str1 = "A"
  20. var str2 = "B"
  22. print("交换前数据:  \(str1) 和 \(str2)")
  23. swapTwoValues(&str1, &str2)
  24. print("交换后数据: \(str1) 和 \(str2)")

编译运行以上 Swift 范例，输出结果为

  1. $ swift main.swift
  2. 交换前数据:  100 和 200
  3. 交换后数据: 200 和 100
  4. 交换前数据:  A 和 B
  5. 交换后数据: B 和 A

泛型类型

Swift 允许开发者定义自己的泛型类型

自定义类、结构体和枚举作用于任何类型，如同 Array 和 Dictionary 的用法

下面我们来编写一个名为 Stack （栈）的泛型集合类型，栈只允许在集合的末端添加新的元素（称之为入栈），且也只能从末端移除元素（称之为出栈）

Swift 3 泛型 - 图1

图片中从左到右步骤如下：

1.三个值在栈中 2.第四个值被压入到栈的顶部 3.现在有四个值在栈中，最近入栈的那个值在顶部 4.栈中最顶部的那个值被移除，或称之为出栈 5.移除掉一个值后，现在栈又只有三个值了

下面的代码一个非泛型版本的栈，以 Int 型的栈为例

  1. import Cocoa
  3. struct IntStack
  4. {
  5.     var items = [Int]()
  7.     mutating func push(_ item: Int)
  8.     {
  9.         items.append(item)
  10.     }
  12.     mutating func pop() -> Int
  13.     {
  14.         return items.removeLast()
  15.     }
  16. }

这个结构体在栈中使用一个名为 items 的 Array 属性来存储值

Stack 提供了两个方法：push(_:) 和 pop()，用来向栈中压入值以及从栈中移除值

这些方法被标记为 mutating，因为它们需要修改结构体的 items 数组

但这个 IntStack 结构体只能用于 Int 类型

我们可以定义一个泛型 Stack 结构体，从而能够处理任意类型的值

  1. import Cocoa
  3. struct Stack<Element>
  4. {
  5.     var items = [Element]()
  7.     mutating func push(_ item: Element)
  8.     {
  9.         items.append(item)
  10.     }
  11.     mutating func pop() -> Element
  12.     {
  13.         return items.removeLast()
  14.     }
  15. }
  17. var stackOfStrings = Stack<String>()
  18. print("字符串元素入栈: ")
  19. stackOfStrings.push("google")
  20. stackOfStrings.push("baidu")
  21. print(stackOfStrings.items);
  23. let deletetos = stackOfStrings.pop()
  24. print("出栈元素: " + deletetos)
  26. var stackOfInts = Stack<Int>()
  27. print("整数元素入栈: ")
  28. stackOfInts.push(1)
  29. stackOfInts.push(2)
  30. print(stackOfInts.items);

编译运行以上 Swift 范例，输出结果为

  1. $ swift main.swift
  2. 字符串元素入栈: 
  3. ["google", "baidu"]
  4. 出栈元素: baidu
  5. 整数元素入栈: 
  6. [1, 2]

Stack 基本上和 IntStack 相同，占位类型参数 Element 代替了实际的 Int 类型

上面的的代码中，Element 在如下三个地方被用作占位符：

1.创建 items 属性，使用 Element 类型的空数组对其进行初始化

2.指定 push(_:) 方法的唯一参数 item 的类型必须是 Element 类型

3.指定 pop() 方法的返回值类型必须是 Element 类型

扩展泛型类型

扩展一个泛型类型的时候（使用 extension 关键字），并不需要在扩展的定义中提供类型参数列表

更加方便的是，原始类型定义中声明的类型参数列表在扩展里是可以使用的，并且这些来自原始类型中的参数名称会被用作原始定义中类型参数的引用

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

  1. import Cocoa
  3. struct Stack<Element>
  4. {
  5.     var items = [Element]()
  7.     mutating func push(_ item: Element)
  8.     {
  9.         items.append(item)
  10.     }
  12.     mutating func pop() -> Element {
  13.         return items.removeLast()
  14.     }
  15. }
  17. extension Stack
  18. {
  19.     var topItem: Element?
  20.     {
  21.        return items.isEmpty ? nil : items[items.count - 1]
  22.     }
  23. }
  25. var stackOfStrings = Stack<String>()
  26. print("字符串元素入栈: ")
  27. stackOfStrings.push("google")
  28. stackOfStrings.push("baidu")
  30. if let topItem = stackOfStrings.topItem {
  31.     print("栈中的顶部元素是：\(topItem).")
  32. }
  34. print(stackOfStrings.items)

范例中 topItem 属性会返回一个 Element 类型的可选值

  • 当栈为空的时候，topItem 会返回 nil
  • 当栈不为空的时候，topItem 会返回 items 数组中的最后一个元素

编译运行以上 Swift 范例，输出结果为

  1. $ swift main.swift
  2. 字符串元素入栈: 
  3. 栈中的顶部元素是：baidu.
  4. ["google", "baidu"]

我们也可以通过扩展一个存在的类型来指定关联类型。

例如 Swift 的 Array 类型已经提供 append(_:) 方法，一个 count 属性，以及一个接受 Int 类型索引值的下标用以检索其元素

这三个功能都符合 Container 协议的要求，所以我们只需简单地声明 Array 采纳该协议就可以扩展 Array

下面的代码创建一个空扩展即可

  1. extension Array: Container {}

类型约束

类型约束指定了一个必须继承自指定类的类型参数，或者遵循一个特定的协议或协议构成

语法

我们可以写一个在一个类型参数名后面的类型约束，通过冒号分割，来作为类型参数链的一部分

这种作用于泛型函数的类型约束的基础语法如下所示（和泛型类型的语法相同）

  1. func someFunction<T: SomeClass, U: SomeProtocol> (someT: T, someU: U)
  2. {
  3.     // 这里是泛型函数的函数体部分
  4. }

上面这个函数有两个类型参数

1.第一个类型参数 T，有一个要求 T 必须是 SomeClass 子类的类型约束

2.第二个类型参数 U，有一个要求 U 必须符合 SomeProtocol 协议的类型约束

  1. import Cocoa
  3. // 非泛型函数，查找指定字符串在数组中的索引
  4. func findIndex(ofString valueToFind: String, in array: [String]) -> Int?
  5. {
  6.     for (index, value) in array.enumerated() {
  7.         if value == valueToFind {
  8.             // 找到返回索引值
  9.             return index
  10.         }
  11.     }
  12.     return nil
  13. }
  16. let strings = ["google", "weibo", "taobao", "baidu", "facebook"]
  18. if let foundIndex = findIndex(ofString: "baidu", in: strings)
  19. {
  20.     print("简单教程 的索引为 \(foundIndex)")
  21. }

编译运行以上 Swift 范例，输出结果为

  1. $ swift main.swift
  2. baidu 的索引为 3

关联类

Swift 中使用 associatedtype 关键字来设置关联类型实例

下面的代码定义了一个 Container 协议，该协议定义了一个关联类型 ItemType

Container 协议只指定了三个任何遵从 Container 协议的类型必须提供的功能

遵从协议的类型在满足这三个条件的情况下也可以提供其它额外的功能

  1. import Cocoa
  3. // Container 协议
  4. protocol Container
  5. {
  6.     associatedtype ItemType
  7.     // 添加一个新元素到容器里
  8.     mutating func append(_ item: ItemType)
  9.     // 获取容器中元素的数
  10.     var count: Int { get }
  11.     // 通过索引值类型为 Int 的下标检索到容器中的每一个元素
  12.     subscript(i: Int) -> ItemType { get }
  13. }
  15. // Stack 结构体遵从 Container 协议
  16. struct Stack<Element>: Container
  17. {
  18.     // Stack<Element> 的原始实现部分
  19.     var items = [Element]()
  20.     mutating func push(_ item: Element) {
  21.         items.append(item)
  22.     }
  23.     mutating func pop() -> Element {
  24.         return items.removeLast()
  25.     }
  26.     // Container 协议的实现部分
  27.     mutating func append(_ item: Element) {
  28.         self.push(item)
  29.     }
  30.     var count: Int {
  31.         return items.count
  32.     }
  33.     subscript(i: Int) -> Element {
  34.         return items[i]
  35.     }
  36. }
  38. var tos = Stack<String>()
  39. tos.push("google")
  40. tos.push("baidu")
  41. tos.push("taobao")
  42. // 元素列表
  43. print(tos.items)
  44. // 元素个数
  45. print( tos.count)

编译运行以上 Swift 范例，输出结果为

  1. $ swift main.swift
  2. ["google", "baidu", "taobao"]
  3. 3

where 语句

类型约束能够确保类型符合泛型函数或类的定义约束

我们可以在参数列表中通过 where 语句定义参数的约束

可以写一个 where 语句，紧跟在在类型参数列表后面

where 语句后跟一个或者多个针对关联类型的约束，以及（或）一个或多个类型和关联类型间的等价(equality)关系

范例

下面的范例定义了一个名为 allItemsMatch 的泛型函数，用来检查两个 Container 实例是否包含相同顺序的相同元素

如果所有的元素能够匹配，那么返回 true，反之则返回 false

  1. import Cocoa
  3. // Container 协议
  4. protocol Container
  5. {
  6.     associatedtype ItemType
  7.     // 添加一个新元素到容器里
  8.     mutating func append(_ item: ItemType)
  9.     // 获取容器中元素的数
  10.     var count: Int { get }
  11.     // 通过索引值类型为 Int 的下标检索到容器中的每一个元素
  12.     subscript(i: Int) -> ItemType { get }
  13. }
  15. // // 遵循Container协议的泛型TOS类型
  16. struct Stack<Element>: Container {
  17.     // Stack<Element> 的原始实现部分
  18.     var items = [Element]()
  19.     mutating func push(_ item: Element) {
  20.         items.append(item)
  21.     }
  22.     mutating func pop() -> Element {
  23.         return items.removeLast()
  24.     }
  25.     // Container 协议的实现部分
  26.     mutating func append(_ item: Element) {
  27.         self.push(item)
  28.     }
  29.     var count: Int {
  30.         return items.count
  31.     }
  32.     subscript(i: Int) -> Element {
  33.         return items[i]
  34.     }
  35. }
  36. // 扩展，将 Array 当作 Container 来使用
  37. extension Array: Container {}
  39. func allItemsMatch<C1: Container, C2: Container>
  40.     (_ someContainer: C1, _ anotherContainer: C2) -> Bool
  41.     where C1.ItemType == C2.ItemType, C1.ItemType: Equatable {
  43.         // 检查两个容器含有相同数量的元素
  44.         if someContainer.count != anotherContainer.count {
  45.             return false
  46.         }
  48.         // 检查每一对元素是否相等
  49.         for i in 0..<someContainer.count {
  50.             if someContainer[i] != anotherContainer[i] {
  51.                 return false
  52.             }
  53.         }
  55.         // 所有元素都匹配，返回 true
  56.         return true
  57. }
  58. var tos = Stack<String>()
  59. tos.push("google")
  60. tos.push("baidu")
  61. tos.push("taobao")
  63. var aos = ["google", "baidu", "taobao"]
  65. if allItemsMatch(tos, aos) {
  66.     print("匹配所有元素")
  67. } else {
  68.     print("元素不匹配")
  69. }

编译运行以上 Swift 范例，输出结果为

  1. $ swift main.swift
  2. 匹配所有元素