Swift 开发教程系列 - 第10章：泛型

news2024/11/8 6:32:01

泛型（Generics）是一种强大的特性，允许你编写灵活且可重用的代码，适用于多种类型，而无需重复编写代码。泛型在 Swift 中的应用非常广泛，适用于函数、结构体、枚举和类。通过本章的学习，你将掌握泛型的定义、应用场景，以及如何在项目中使用泛型来优化代码。

10.1 泛型基础

泛型允许你编写独立于类型的代码，以支持不同的数据类型。可以在函数、结构体和类中定义泛型，使其适用于任何符合条件的类型。

定义泛型函数

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

var x = 10
var y = 20
swapValues(a: &x, b: &y)
print("x: \(x), y: \(y)")  // 输出："x: 20, y: 10"

在上例中，swapValues 是一个泛型函数，表示函数支持任何类型 T。T 可以是 Int、String 或任何其他类型。

10.2 泛型类型

Swift 允许你定义泛型结构体、类和枚举，使这些类型能够处理不同的数据类型。

泛型结构体示例

struct Pair<T, U> {
    var first: T
    var second: U
}

let intStringPair = Pair(first: 42, second: "Answer")
print(intStringPair)  // 输出："Pair(first: 42, second: "Answer")"

在上例中，Pair 是一个泛型结构体，支持两个不同类型的泛型参数 T 和 U。这样可以构建包含任意两种类型的对象。

10.3 泛型与约束

在泛型中，可以通过类型约束来限制泛型参数必须遵循某个协议，以确保类型符合特定要求。

泛型与约束示例代码

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

let numbers = [1, 2, 3, 4, 5]
if let index = findIndex(of: 3, in: numbers) {
    print("Index of 3: \(index)")  // 输出："Index of 3: 2"
}

在上例中，findIndex 函数使用 T: Equatable 作为类型约束，确保 T 类型可以进行比较操作（即遵循 Equatable 协议）。

10.4 关联类型（Associated Type）

在协议中定义关联类型，可以使协议更具通用性。关联类型是一种占位符，用于定义协议中用到的类型，具体类型在协议被遵循时确定。

关联类型示例代码

protocol Container {
    associatedtype Item
    var items: [Item] { get }
    mutating func addItem(_ item: Item)
}

struct IntContainer: Container {
    var items = [Int]()
    
    mutating func addItem(_ item: Int) {
        items.append(item)
    }
}

var intContainer = IntContainer()
intContainer.addItem(5)
print(intContainer.items)  // 输出：[5]

在上例中，Container 协议定义了一个关联类型 Item，具体类型在实现协议时由类型 IntContainer 决定。

10.5 泛型的实际应用

• 栈（Stack）：一个通用的栈数据结构可以使用泛型来存储不同类型的数据。

• 网络请求：网络库中可以使用泛型来支持不同的响应类型，简化 JSON 解码操作。

• 自定义集合类型：如队列（Queue）、链表（Linked List）等自定义集合类型可以通过泛型支持多种类型的数据。

泛型栈示例

struct Stack<Element> {
    private var elements = [Element]()
    
    mutating func push(_ element: Element) {
        elements.append(element)
    }
    
    mutating func pop() -> Element? {
        return elements.popLast()
    }
}

var intStack = Stack<Int>()
intStack.push(10)
intStack.push(20)
print(intStack.pop() ?? "Empty stack")  // 输出：20