1. 泛型函数
func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
let t = a
a = b
b = t
}
var someInt = 3
var anotherInt = 7
swapTwoValues(&someInt, &anotherInt)
print("\(someInt), \(anotherInt)")
// print "7, 3"
var someString = "hello"
var anotherString = "world"
swapTwoValues(&someString, &anotherString)
T 是占位类型名，用来代替实际类型名。
2. 泛型类型
下面的例子定义了一个泛型的栈（stack）结构体，从而能够处理任意类型的值。
struct Stack<Element> {
var items = [Element]()
mutating func push(item: Element) {
items.append(item)
}
mutating func pop() -> Element {
return items.removeLast()
}
}
var stackOfStrings = Stack<String>()
stackOfStrings.push(item: "A")
stackOfStrings.push(item: "B")
stackOfStrings.push(item: "C")
let fromTheTop = stackOfStrings.pop()
3. 扩展一个泛型类型
extension Stack {
var topItem: Element? {
return items.isEmpty ? nil : items[items.count - 1]
}
}
stackOfStrings.topItem // "B"
4. 类型约束
func findIndex(ofString valueToFind: String, in array: [String]) -> Int? {
for(index, value) in array.enumerated() {
if value == valueToFind {
return index
}
}
return nil
}
let strings = ["A", "B", "C"]
if let foundIndex = findIndex(ofString: "B", in: strings) {
print("\(foundIndex)")
}
// print "1"
上面的例子展示了在一个字符串数组中找到对应字符串的索引，但是并不适用于包含其他类型的元素的数组。
func findIdex<T: Equatable>(array: [T], _ valueToFind: T) -> Int? {
for (index, value) in array.enumerated() {
if value == valueToFind {
return index
}
}
return nil
}
Equatable 给占位类型 T 添加了类型约束，意味着上面的函数只能包含 Equatable 类型的元素。不是所有的 Swift 类型都可以用 == 进行比较，除非该类型遵循了 Equatable 协议。
5. 关联类型
关联类型为协议中的某个类型提供了一个占位名，其代表的实际类型在协议被采纳时才会被指定，用关键字 associatedtype 关键字来指定关联类型。
protocol Container {
associatedtype ItemType
mutating func append(item: ItemType)
var count: Int { get }
subscript(i: Int) -> ItemType { get }
}
我们还可以通过扩展一个存在的类型来指定关联类型，比如：
extension Array: Container {}
6. 泛型Where语句
where 字据可以给一个关联类型添加类型约束，语法如下：
func genericFunc<S>(p: S) -> returnType where #判断语句# {
}
