Swift进阶（十三）泛型

作者: Jax_YD | 来源:发表于2021-01-25 16:09 被阅读0次

Swift进阶（十三）泛型
Swift进阶：泛型
Swift进阶-泛型
Swift进阶之泛型
Swift-进阶：泛型
【Swift进阶笔记】泛型
Swift进阶十一:泛型
Swift-泛型笔记
[ WWDC2018 ] - Swift 泛型 Swift Ge
Swift 运用协议泛型封装网络层

泛型（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

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

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
    }
}

$\color{orange}{提示：这里使用别名会更规范一些，另外跟Xcode的智能提示结合的更好}$
② 样式二
除了上面的写法，我们还可以这样写：

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
这是因为在编译阶段，代码只能明确r1和r2的类型，但是并不清楚Speed的类型，只有在运行时，根据返回的类型才能够知道。注意：这里即使是将Runnable设置成函数参数也是一样的。
下面我们来看一下怎么解决这个问题：

方案①： $\color{red}{使用泛型}$

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

\color{orange}{注意：}

这里使用as!进行强转是有一定风险的，如果var r1: Car = get(0)样写，就会出问题的。所以根据实际情况做调整。

方案②： $\color{red}{使用不透明类型}$ （Opaque Type）
使用some关键字声明一个不透明类型

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

$\color{red}{注意：}$ some $\color{red}{限制只能返回一种类型}$

image.png
讲到这里，可能有人就有疑问了？既然只能返回一种类型，那为什么不直接把Runnable换成Person或者Car不是更直接吗？
其实这样写的目的正如这个类型的名字一样不透明类型，是为了保护类里面其他的代码，一些不想暴露的API。
假设Car还有其他的参数，比如color，Brand等等，但是在这个地方，并不想让此时的使用者去了解过多的信息，只需要知道可以使用speed就可以了。这就是为什么使用协议，而不是直接返回具体类型的意义
同时，我们也可以看到r1 和 r2也不会暴露出具体的类型：

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
编译器告诉我们case nil这个模块永远不会被执行，这是为什么呢？

因为在switch中，可选项的绑定是 $\color{red}{直接赋值}$ 的，在这里是没有进行解包的，因此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

Swift进阶（十三）泛型
泛型（Generics）泛型可以将类型参数化，提高代码复用率，减少代码量下面我们来看一个经典的例子，a b交换，...
Swift进阶：泛型
swift 进阶之路：学习大纲[https://www.jianshu.com/p/115367c3eefd] 本...
Swift进阶-泛型
为什么会有泛型？我们发现， multiNumInt(::) 、 multiNumDouble(::) 函数体是...
Swift进阶之泛型
泛型Generic在swift中非常重要，它提升了代码的通用性和简洁性，很多开源的组件都是通过泛型来实现。泛型是什...
Swift-进阶：泛型
本文主要介绍泛型及其底层原理泛型泛型主要用于解决代码的抽象能力 + 代码的复用性例如下面的例子，其中的T就是...
【Swift进阶笔记】泛型
泛型类型可选类型是泛型 Array, Dictionary, Set也是泛型，如果不指定类型，系统默认为Any类...
Swift进阶十一:泛型
一:重载重载和泛型紧密相关.拥有同样名字，但是参数或返回类型不同的多个方法互相称为重载方法，方法的重载并不意味着...
Swift-泛型笔记
Swift 泛型 Swift 提供了泛型让你写出灵活且可重用的函数和类型。 Swift 标准库是通过泛型代码构建出...
[ WWDC2018 ] - Swift 泛型 Swift Ge
Swift 泛型历史我们首先来回顾一下 Swift 中对于泛型支持的历史变更，看看现在在 Swift 中，泛型都...
Swift 运用协议泛型封装网络层
Swift 运用协议泛型封装网络层 Swift 运用协议泛型封装网络层