Swift進階之泛型

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

參考鏈接

最后編輯于
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明:文章內容(如有圖片或視頻亦包括在內)由作者上傳并發布,文章內容僅代表作者本人觀點,簡書系信息發布平臺,僅提供信息存儲服務。

推薦閱讀更多精彩內容