泛型（Generics）

• 泛型可以将类型参数化，提高代码复用率，减少代码量
  下面我们来看一个经典的例子，a b交换，正常情况下，我们是这样交换的：

func swapValues(_ a: inout Int, _ b: inout Int) {
    let temp = a
    a = b
    b = temp
}

学过元组之后，我们可以利用元组，精简一下代码：

func swapValues(_ a: inout Int, _ b: inout Int) {
    (a, b) = (b, a)
}

那么当我们需要交换更多类型数据的时候，通常我们会进行函数重载：

func swapValues(_ a: inout Int, _ b: inout Int) {
    (a, b) = (b, a)
}

func swapValues(_ a: inout Double, _ b: inout Double) {
    (a, b) = (b, a)
}

func swapValues(_ a: inout String, _ b: inout String) {
    (a, b) = (b, a)
}
......

函数重载以后会产生大量胶水代码。
那么此时，我们的泛型就有了用武之地，我们可以这样写：

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

函数名后面的<T>中的T，就代表之中不确定的类型，T就是泛型。（T也可以写成其他的名字）
此时swapValues就是泛型函数，并且在Swift的泛型函数里面，能够自动识别参数类型。

• 将泛型函数赋值给变量
  我们都知道，可以将函数赋值给变量，如下：

func sum(_ a: Int, _ b: Int) -> Int { a + b }
var fn = sum
fn(10, 20) // 30

但是，当我们要将泛型函数赋值给变量的时候，就不能这么写了；区别就是，泛型函数赋值给变量的时候，要明确函数的类型：

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

var swapV: (inout Int, inout Int ) -> () = swapValues

当前情况下，泛型函数传入的两个参数的类型是相同的，那么我们可以不可以传入不同类型的参数呢？答案是可以的，我么可以这样写：

func swapValues<T, E>(_ a: inout T, _ b: inout E) {
    //......
}

泛型类型

• 用类定义一个栈：

class Stack<E> {
    var elements = [E]()
    func push(_ element: E) {
        elements.append(element)
    }
    func pop() -> E {
        elements.removeLast()
    }
    func top() -> E {
        elements.last!
    }
    func size() -> Int {
        elements.count
    }
}

那么此时，栈里面可以存入任意类型的数据，栈初始化的时候如果明确了E的类型，那就只能存入单一类型的数据，如果不想使用单一类型可以使用Any,但是不能缺少类型：

var intStack = Stack<Int>()
var stringStack = Stack<String>()
var anyStack = Stack<Any>()

image.png

如果存在继承要使用下面的方式：

class SubStack<E>: Stack<E> {}

• 将类换成结构体：
  这里要注意mutating，结构体的实例方法里面修改结构体的内存。
  这个只是点在Swift进阶（六）方法 & 下标讲过。

struct Stack<E> {
    var elements = [E]()
    mutating func push(_ element: E) {
        elements.append(element)
    }
    mutating func pop() -> E {
        elements.removeLast()
    }
    func top() -> E {
        elements.last!
    }
    func size() -> Int {
        elements.count
    }
}

• 将类换成枚举

enum Score<T> {
    case point(T)
    case grade(String)
}
let score0 = Score<Int>.point(100)
let score1 = Score.point(110)
let score2 = Score.point(120)
let score3 = Score<Int>.grade("A")

这里大家注意最后一行代码，这里没有使用到point为什么也要给泛型明确类型呢？因为如果不明确的话，Score就没办法确定要分多少内存，所以这里即使是没有使用，也要明确一下。

关联类型（Associated Type）

• 关联类型的作用：给协议中用到的类型定义一个占位名称
• 协议中可以拥有多个关联类型

protocol Stackable {
    associatedtype Element // 关联类型
    mutating func push(_ element: Element)
    mutating func pop() -> Element
    func top() -> Element
    func size() -> Int
}

注意：上面协议中使用mutating是因为协议可能被结构体遵守。

• 定义一个类去遵守协议
  ① 样式一

class StringStack: Stackable {
    typealias Element = String
    
    var elements = [String]()
    func push(_ element: String) {
        elements.append(element)
    }
    func pop() -> String {
        elements.removeLast()
    }
    func top() -> String {
        elements.last!
    }
    func size() -> Int {
        elements.count
    }
}

当然，这里也可以不适用别名：

class StringStack: Stackable {
    var elements = [String]()
    func push(_ element: Element) {
        elements.append(element)
    }
    func pop() -> String {
        elements.removeLast()
    }
    func top() -> String {
        elements.last!
    }
    func size() -> Int {
        elements.count
    }
}

② 样式二
除了上面的写法，我们还可以这样写：

class Stack<E>: Stackable {
    typealias Element = E
    var elements = [E]()
    func push(_ element: E) {
        elements.append(element)
    }
    func pop() -> E {
        elements.removeLast()
    }
    func top() -> E {
        elements.last!
    }
    func size() -> Int {
        elements.count
    }
}

同样的，这种写法的别名使用，跟第一种是一样的，同样可以省略。

类型约束

protocol Runnable {}
class Person {}
func swapValues<T: Person & Runnable>(_ a: inout T, _ b: inout T) {
    (a, b) = (b, a)
}

swapValues中设置泛型T，并且T必须是Person类型或其子类型，同时T必须遵守Runnable协议。

我们再来看一个复杂一点的：
第一步：定义Stackable协议，协议里面定义关联类型并遵守Equatable协议

protocol Stackable {
    associatedtype Element: Equatable
}

第二步：定义Stack类，并遵守Stackable协议，这里要注意：Stack里面的泛型也要遵守Equatable协议

class Stack<E : Equatable>: Stackable {
    typealias Element = E
}

第三步：定义equal函数，有两个泛型S1 & S2，S1 & S2都遵守Stackable协议；并且使用where添加更复杂的条件：S1 和 S2的关联类型相同，S1的关联类型遵守Hashable协议

func equal<S1: Stackable, S2: Stackable>(_ s1: S1, _ s2: S2) -> Bool where S1.Element == S2.Element, S1.Element : Hashable {
    return true
}

接下来我们执行以下代码

image.png

到这里，想必大家已经知道如何使用类型约束了。

协议类型的注意点

我们先看一段正常的代码：

• Person 和 Car都遵守Runnable协议
• 定义一个函数，通过条件返回遵守Runnable协议的类

protocol Runnable {}
class Person: Runnable {}
class Car: Runnable {}

func get(_ type: Int) -> Runnable {
    if type == 0 {
        return Person()
    }
    return Car()
}
var r1 = get(0)
var r2 = get(1)

• 此时如果协议中添加一个关联类型呢？

protocol Runnable {
    associatedtype Speed
    var speed: Speed {get}
    
}
class Person: Runnable {
    typealias Speed = Double
    var speed: Double {5.0}
}
class Car: Runnable {
    typealias Speed = Int
    var speed: Int {100}
}

此时会发现get方法会报错：

image.png

• 方案①：

func get<T: Runnable>(_ type: Int) -> T  {
    if type == 0 {
        return Person() as! T
    }
    return Car() as! T
}
var r1: Person = get(0)
var r2: Car = get(1)

image.png

• 方案②：（Opaque Type）
  使用some关键字声明一个不透明类型

func get(_ type: Int) -> some Runnable {
    return Car()
}
var r1 = get(0)
var r2 = get(1)

some

image.png

image.png

• some除了用在返回值类型上，一般还可以用在属性类型上
  
  image.png

可选项的本质

• 可选项的本质是enum类型

public enum Optional<Wrapped> : ExpressibleByNilLiteral {
    case none
    case some(Wrapped)
    public init(_ some: Wrapped)
}

根据上面的代码我们知道，可选类型的取值只有两种：
① none
② some，有一个关联值Wrapped
因此下面几行代码是等价的

var age: Int? = 10
var age0: Optional<Int> = Optional<Int>.some(10)
var age1: Optional = .some(10)
var age2 = Optional.some(10)
var age3 = Optional(10)
var age4 = Optional.init(10)

var age: Int? = nil
age = .none
var age0 = Optional<Int>.none
var age1: Optional<Int> = .none

其实我们平时写的Int?这种就是语法糖。

• 枚举在switch中的应用，可选项的绑定问题

var age: Int? = nil
age = 10
age = .some(20)
age = nil

那我们来看一下，在switch中的应用
① 我们直接来进行可选项绑定，会发现编译器会给我警告⚠️

image.png

因为在switch中，可选项的绑定是的，在这里是没有进行解包的，因此case let v是包含nil的。那这样就达不到我们的预期效果。
我们可以用下面两种方法解决这个问题：

// 方法一 在可选项绑定的时候，在后面加 "?"
switch age {
case let v?:
    print("有值", v)
case nil:
    print("没有值")
}

// 方法二 利用可选项本质是枚举的特征
switch age {
case let .some(v):
    print("有值", v)
case .none:
    print("没有值")
}

• 我们再来看一下多重可选项

var age: Int = 10
var age_: Int?? = age


// 也可以这样写
var age0 = Optional.some(Optional.some(10))
age0 = nil
var age1: Optional<Optional> = .some(.some(10))
age1 = .none

大家要知道：

var age: Int?? = 10
// 等价于
var age0: Optional<Optional> = 10