Swift 泛型(Generics)

学习记录，有搬运

Swift泛型能够让你根据自己的需求，写出通用于的，灵活的，可复用的函数。泛型是Swfit最强大的特性之一，广泛用于个基础库.
泛型可将类型参数化，提高代码复用率，减少代码量

泛型函数

函数使用了一个“占位符类型”，其规定参数和只能是同一个类型。或者说都是所表示的类型
泛型函数可用于任何类型
如下：
inout修饰语传送门

func swapValue(a: inout T,b: inout T) {
        let temp = a
        a = b
        b  = temp
}        
var aa = 10
var bb = 20
swapValue(a: &aa, b: &bb)
//或者
var aa = "10"
var bb = "20"
swapValue(a: &aa, b: &bb)

其中会自动推断类型为或者，还可以是任意其他类型，如[],这样就不用判断类型，直接调用函数即可

泛型类型

Swift允许你定义自己的泛型类型。它们是可以用于任意类型的自定义类、结构体、枚举，和、方式类似。
比如，自定义一个类型，实现方便地存储数据到数组。
如下：

struct Stack {
    //Element为占位类型，可随意命名
    var items = [Element]()
    mutating func push(item:Element) {
        items.insert(item, at: 0)
    }
    mutating func pop(){
        items.removeFirst()
    }
}
//创建时，指定占位类型为String类型
var stack = Stack()
stack.push(item: "a")
stack.push(item: "b")
stack.push(item: "c")
Swift.print(stack)
Swift.print("pop")
stack.pop()
Swift.print(stack)

关联类型(AssociatedType)

定义一个协议时，有时候在协议中声明一个或多个关联类型是很有用的。关联类型即，把一个"占位类型"给协议中用到的类型。直到采纳协议时才指定T的实际类型。关联类型通过associatedType关键字指定。

protocol Stackable {
    associatedtype Element // 关联类型，这时还未确定具体是什么类型
    var items:[Element]  { get set }
    mutating func push(item:Element)
    mutating func pop()
    func top() -> Element?
    func size() -> Int
}
extension Stackable{//通过分类实现默认函数
    mutating func push(item:Element){
        items.insert(item, at: 0)
    }
    mutating func pop(){
        items.removeFirst()
    }
    func top() -> Element?{
        items.first
    }
    func size() -> Int{
        items.count
    }
}

class StringStack: Stackable,CustomStringConvertible {
    //给关联类型设定为String
    typealias Element = String
    var items: [String] = [String]()
    //重写控制台打印内容
    var description: String{
        var dict: [String: Any] = [:]
        // 遍历所有属性
        Mirror(reflecting: self).children.forEach { (child) in
            guard let key = child.label else { return }
            dict[key] = child.value
        }
        return "\(Self.self): \(dict)"
    }
}

协议中也可以申明多个关联类型

类型约束

指出一个类型形式参数，必须继承自特定类，或遵循一个特定协议、组合协议。

protocol Runable {
    
}
class Person {
    func swapValues(a: inout T,b: inout T) {
        (a,b) = (b,a)
    }
}

可选项的本质是类型

public enum CustomOptional {
    case none
    case some(Wrapped)
}
 var age1:CustomOptional = .some(10)
 var age2 = CustomOptional.some(10)
 var age3:CustomOptional = .some(10)
 age3 = .none