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"])
