Swift高级特性之泛型

泛型是一种在编程语言中实现通用性的特性，它允许我们编写可以适应不同数据类型的代码。在Swift中，泛型可以应用于函数、类、结构体和枚举。

1.泛型函数：使用泛型函数可以编写一次代码，用于处理不同类型的数据。例如，我们可以编写一个泛型函数来交换任意两个变量的值：

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

var num1 = 10
var num2 = 20
swap(&num1, &num2)
print("num1 = \(num1), num2 = \(num2)")  // 输出：num1 = 20, num2 = 10

var str1 = "Hello"
var str2 = "World"
swap(&str1, &str2)
print("str1 = \(str1), str2 = \(str2)")  // 输出：str1 = World, str2 = Hello

2.泛型类型：使用泛型类型可以编写可以处理不同类型数据的类、结构体和枚举。例如，我们可以编写一个泛型栈来存储任意类型的元素：

struct Stack<Element> {
    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)
intStack.push(30)
print(intStack.pop())  // 输出：Optional(30)

var strStack = Stack<String>()
strStack.push("Hello")
strStack.push("World")
strStack.push("!")
print(strStack.pop())  // 输出：Optional("!")

3.泛型约束：使用泛型约束可以限制泛型类型的范围。例如，我们可以在泛型函数中使用泛型约束，限制参数类型必须遵循某个协议：

protocol Comparable {
    static func >(lhs: Self, rhs: Self) -> Bool
}

func findMax<T: Comparable>(_ array: [T]) -> T? {
    guard !array.isEmpty else {
        return nil
    }
    
    var max = array[0]
    for element in array {
        if element > max {
            max = element
        }
    }
    return max
}

let numbers = [1, 2, 3, 4, 5]
let maxNumber = findMax(numbers)
print(maxNumber)  // 输出：Optional(5)

let strings = ["Hello", "World", "!"]
let maxString = findMax(strings)
print(maxString)  // 输出：Optional("World")

泛型是Swift中非常强大和灵活的特性之一，它能够让我们写出更加通用和可复用的代码。通过使用泛型，我们可以大幅减少重复代码的数量，并且提高代码的可读性和可维护性。