swift-generic.jpg
泛型Generic在swift中非常重要，它提升了代码的通用性和简洁性，很多开源的组件都是通过泛型来实现。泛型是什么呢？字面意思大概就是宽泛的类型，在swift中泛型非常灵活，涉及到的概念也相对较多，笔者写下这篇文章做一个小小的总结，有疏漏的地方以后会慢慢补全。读者朋友可以在文章底部，找到参考链接。
1. 写一个泛型函数
func addInts(x: Int, y: Int) -> Int {
return x + y
}
let intSum = addInts(x: 1, y: 2)
print(intSum)
func addDoubles(x: Double, y: Double) -> Double {
return x + y
}
func add1<T>(x: T, y: T) {
return x + y
}
2. 标准库中的泛型引用
在swift中，标准库Array, Dictionary, Optional都是基于泛型实现的，按住键盘的option按键，鼠标点击下面的数组和字典变量，即可看到该变量是泛型类型，
let numbers = [1, 2, 3]
let firstNumber = numbers[0]
var numbersAagin: Array<Int> = []
numbersAagin.append(1)
numbersAagin.append(2)
numbersAagin.append(3)
//numbers.append("All hail load")
let countryCodes = ["Arendelle": "AR", "Genovia":"GN", "Freedonia": "FD"]
let countryCode = countryCodes["Freedonia"]
let optionalName = Optional<String>.some("Princess Moana")
if let name = optionalName {
print(name)
}
3. 泛型类型
通过构造一个泛型队列Queue，来简单介绍泛型类型，如下代码所示，
struct Queue<Element> {
fileprivate var elements: [Element] = []
mutating func enqueue(newElement: Element) {
elements.append(newElement)
}
mutating func dequeue() -> Element? {
guard !elements.isEmpty else { return nil }
return elements.remove(at: 0)
}
}
var q = Queue<Int>()
q.enqueue(newElement: 4)
q.enqueue(newElement: 2)
print(q.dequeue())
print(q.dequeue())
print(q.dequeue())
在swift中定义class, struct, enum时，都可以通过泛型来进行定义，现在定义一个泛型结构体SquareMartrix，它表示一个n * n的矩阵，定义如下，
struct SquareMatrix<T> {
var backingArray: [T] = []
let size: Int
func itemAt(row: Int, column: Int) -> T {
return ...
}
init(size: Int, initial: T) {
self.size = size
backingArray = Array(repeating: initial, count: size * size)
}
}
let a = SquareMatrix(size: 10, initial: 50)
let b : SquareMatrix<String?> = SquareMatrix(size: 5, initial: nil)
因为SquareMatrix是通过泛型定义，所以可以存放Int和String内容。
4. 泛型函数
下面的泛型函数，将字典内容转换为元组数组，
func pairs<Key, Value>(from dictionary: [Key: Value]) -> [(Key, Value)] {
return Array(dictionary)
}
let somePairs = pairs(from: ["mininum": 199, "maxinum": 299])
print(somePairs)
let morePairs = pairs(from: [1: "swift", 2: "Generics", 3: "Rule"])
print(morePairs)
5. 泛型约束
func middle<T: Comparable>(array: [T]) -> T? {
guard !array.isEmpty else { return nil }
return array.sorted()[(array.count-1) / 2]
}
middle(array: [2, 5, 1, 3, 4])
protocol Summable {
static func +(lhs: Self, rhs: Self) -> Self
}
extension Int: Summable {
}
extension Double: Summable {
}
func add2<T: Summable>(x: T, y: T) -> T {
return x + y
}
let addIntSum = add2(x: 1, y: 2)
print(addIntSum)
let addDoubleSum = add2(x: 10.0, y: 14.0)
print(addDoubleSum)
extension String: Summable {
}
let addString = add2(x: "Generics", y: "Are awesome!")
print(addString)
6. 扩展泛型类型
在swift中通过extension来进行扩展，如下代码所示，为Queue扩展一个peek方法，该方法返回队列中的第一个元素，
extension Queue {
func peek() -> Element? {
return elements.first
}
}
7. 继承泛型类型
class Box<T> {
}
class Gift<T>: Box<T> {
func wrap() {
}
}
class Rose {
}
class ValentinesBox: Gift<Rose> {
override func wrap() {
print("wrap with love paper")
}
}
class Shoe {
}
class GlassSlipper: Shoe {
}
class ShoeBox: Box<Shoe> {
}
let box = Box<Rose>()
let gift = Gift<Rose>()
let shoeBox = ShoeBox()
let valentines = ValentinesBox()
gift.wrap()
8. 泛型定义枚举的关联值
enum Result<Value> {
case success(Value)
case failure(Error)
}
enum MathError: Error {
case divisionByZero
}
func divide(_ x: Int, by y: Int) -> Result<Int> {
guard y != 0 else { return .failure(MathError.divisionByZero) }
return .success(x / y)
}
9. 在协议中使用关联类型associatedType作为泛型
在Protocol中不能使用泛型，但可以使用associatedType来替代泛型，如下代码所示，
protocol Animal {
associatedtype Food
func eat(food: Food)
}
struct Cow: Animal {
typealias Food = String
func eat(food: Food) {
print("my food can be any string")
}
}
let cow = Cow()
cow.eat(food: "corn")
struct Chicken: Animal {
enum Food: String {
case grass, corn
}
func eat(food: Food) {
switch food {
case .grass:
print("My food is a grass enum")
case .corn:
print("my food is a corn enum")
}
}
}
let chicken = Chicken()
chicken.eat(food: .grass)
struct Dog: Animal {
typealias Food = [String]
func eat(food: Food) {
food.forEach { print("I am eating an array of food, current is \($0)") }
}
}
let dog = Dog()
dog.eat(food: ["cake", "treat", "bone"])
