Swift 泛型

泛型是 Swift 编程语言中的一个强大功能，它允许你编写更加灵活和重用的代码。通过使用泛型，你可以创建可以处理多种数据类型的函数、方法、类和结构体，而无需牺牲类型安全性和代码清晰度。

泛型函数

基础概念

泛型函数允许你在定义函数时指定一个或多个类型参数，这些类型参数在函数体内可以像普通类型一样使用。这使得函数能够接受多种不同类型的输入，同时保持类型安全性。

示例：交换函数

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

在这个例子中，T 是一个类型参数，表示任意类型。inout 关键字表明参数可以在函数内部被修改，并且这些修改会在函数外部反映出来。

使用泛型函数

var intArray = [1, 2, 3]
swapValues(&intArray[0], &intArray[1])

var stringArray = ["apple", "banana"]
swapValues(&stringArray[0], &stringArray[1])

这里我们使用了同一个 swapValues 函数来交换整数数组和字符串数组中的元素，展示了泛型的强大之处。

类型约束

你可以为泛型类型参数添加类型约束，以限制只能使用特定类型或者满足某些条件的类型。例如，如果你希望你的泛型函数只适用于实现了某种协议的类型，你可以这样做：

// www.javascriptcn.com code example
protocol Printable {
    func print()
}

struct Book: Printable {
    var title: String
    
    func print() {
        print("Book Title: \(title)")
    }
}

func printValue<T: Printable>(_ value: T) {
    value.print()
}

let book = Book(title: "The Great Gatsby")
printValue(book)

在这个例子中，Printable 协议被用来约束泛型类型参数 T，只有实现了 Printable 协议的类型才能作为参数传递给 printValue 函数。

泛型类型

除了泛型函数外，Swift 还支持泛型类型。这意味着你可以创建可以处理任何类型数据的类、结构体或枚举。

泛型类

下面是一个简单的泛型类示例，用于存储任何类型的值：

// www.javascriptcn.com code example
class Box<T> {
    private var content: T
    
    init(content: T) {
        self.content = content
    }
    
    func getContent() -> T {
        return content
    }
    
    func setContent(newContent: T) {
        content = newContent
    }
}

let intBox = Box<Int>(content: 10)
print(intBox.getContent())

let stringBox = Box<String>(content: "Hello, World!")
print(stringBox.getContent())

在这个例子中，Box 类可以存储任何类型的值，因为 T 是一个类型参数。你可以创建存储整数或字符串的 Box 实例。

泛型枚举

Swift 中的枚举也可以是泛型的，这样它们可以容纳不同类型的数据。下面是一个示例：

// www.javascriptcn.com code example
enum OptionalValue<Wrapped> {
    case none
    case some(Wrapped)
}

let possibleInteger: OptionalValue<Int> = .some(100)
let possibleString: OptionalValue<String> = .some("Hello, Swift")

if case .some(let value) = possibleInteger {
    print("Integer value is \(value)")
}

if case .some(let value) = possibleString {
    print("String value is \(value)")
}

这个例子展示了一个名为 OptionalValue 的泛型枚举，它可以表示某种类型的可选值。通过使用不同的类型参数，它可以容纳不同类型的数据。

泛型类型约束

正如在泛型函数中所讨论的那样，泛型类型也可以有类型约束。这允许你指定泛型类型参数必须遵循哪些协议或实现哪些特性。

示例：泛型类型约束

// www.javascriptcn.com code example
protocol Identifiable {
    var id: String { get set }
}

class User: Identifiable {
    var id: String
    init(id: String) {
        self.id = id
    }
}

class Product: Identifiable {
    var id: String
    init(id: String) {
        self.id = id
    }
}

class Database<T: Identifiable> {
    private var items: [T] = []
    
    func add(_ item: T) {
        items.append(item)
    }
    
    func remove(_ item: T) {
        if let index = items.firstIndex(where: { $0.id == item.id }) {
            items.remove(at: index)
        }
    }
    
    func getAll() -> [T] {
        return items
    }
}

var databaseOfUsers = Database<User>()
databaseOfUsers.add(User(id: "1"))
databaseOfUsers.add(User(id: "2"))

var databaseOfProducts = Database<Product>()
databaseOfProducts.add(Product(id: "A1"))
databaseOfProducts.add(Product(id: "B2"))

在这个例子中，Database 类被设计成只能存储实现了 Identifiable 协议的对象。这确保了每个对象都有一个唯一的标识符，从而可以正确地添加、删除和查询数据库中的项。

泛型扩展

除了为现有类型添加属性和方法之外，你还可以为它们添加泛型功能。这允许你为现有的类型添加更多的灵活性，而无需改变其原始定义。

示例：为 Int 添加泛型方法

// www.javascriptcn.com code example
extension Int {
    func repeatPrint<T>(_ value: T) where T: CustomStringConvertible {
        for _ in 0..<self {
            print(value)
        }
    }
}

5.repeatPrint("Hello, Generic World!") // 打印 Hello, Generic World! 五次

在这个例子中，我们为 Int 类型添加了一个泛型方法 repeatPrint。这个方法接受一个实现了 CustomStringConvertible 协议的值，并根据调用者的值重复打印该值。

总结

泛型是 Swift 中非常强大的功能之一，它使代码更具通用性、可重用性和类型安全性。通过使用泛型，你可以编写更加灵活的代码，同时保持类型安全。无论是函数、类还是枚举，泛型都可以帮助你构建更加强大和灵活的应用程序。