Swift中的泛型

时隔1个月，2个月，3个月。。。我终于回来了。。公司项目太忙了以至于简书一直没有更新。而且公司项目还是OC的。。最近忙的也差不多了，还得继续学咱们的Swift啊，那么今天呢，就写一篇我对Swift中泛型的理解吧。

泛型（generic）

泛型是Swift的强大特征之一，它可以让我们的代码更加灵活，让我们的函数可重用性更高，可以让我们的代码更利于维护，逻辑更加清晰。

---

泛型的使用场景

现在我们有一个这样的需求交换两个整数的值，那么我们的函数可能是这样写的

func swapInt(inout a: Int, inout b: Int) {
    let temp = a
    a = b
    b = temp
}
    var a = 10
    var b = 20
    // 函数调用
    swapInt(&a, b: &b)

这时候我们感觉万事大吉了，下班回家！产品一句话需求改了现在要交换两个String的值，沃嚓。。难到还得写个函数，这时候Swift中泛型的作用就有展现的地方了，只需稍作改动我们的函数就会变得非常强大。

func swapGeneric <T>(inout a: T, inout b: T) {
    let temp = a
    a = b
    b = temp
}
    var str = "Hello, playground"
    var str1 = "Hello, World"
    // 函数调用
    swapGeneric(&str, b: &str1)

那么我们来对比一下这两个函数

func swapInt(inout a: Int, inout b: Int)
func swapGeneric<T>(inout a: T, inout b: T)

我们可以容易的发现泛型函数无非就是使用了节点类型命名，通常我们用字母T来代替实际类型名(如Int，String，Float等)，当有多种类型的时候可以用U，E或其他字符表示，这个没有强制要求，都是写习惯了自然就用那几个字母了。节点类型名并不是表示T必须是任何类型，而是表示规定a和b必须是同一个类型的T，只有函数在每一次调用的时候传入的实际类型才能决定T所代表的类型。

---

泛型约束

我们有一个判断两个参数是否相等的泛型函数，如下

// ❌
func isEquals<T>(a: T, b: T) -> Bool {
    return (a == b)
}

是不是你也觉得这样写是对的？这样写其实很明显是错误的，仔细想一下a和b有可比性嘛，很显然是没有的，所以我们需要这个泛型T遵守Comparable协议，也就是我们要给这个泛型T添加约束，只有符合这个约束的类型才能使用这个函数，改进的函数如下

// ✅
func isEquals<T: Comparable>(a: T, b: T) -> Bool {　
    return (a == b)
}

---

如果你使用Swift编写代码，却说自己没有用到过泛型，那只能说明😄。。许多Swift标准库是通过泛型代码构建出来的，最常见的例子：Swift的Array和Dictionary类型都是泛型集，你可以创建Int类型的数组，也可以创建String类型的，同样也可以创建存储任何指定类型的字典，而且这些类型可以是没有限制的。

更深入的理解泛型

上一篇简书我们介绍了Swift数组中Map,FlatMap,Filter,Reduce的使用，那么今天就来说一下Map以及Reduce的内部实现，从而更深入的理解Swift中的泛型。

MyMap

首先我们先看看使用Swift中原有map的实现，代码如下

let fruits = ["apple", "banana", "orange"]
// 将字符串转换成字符串的长度
func fruit(fruit: String) -> Int? {
    let length = fruit.characters.count
    guard length > 0 else {
        return nil
    }
    return length
}
// map接受一个定义规则的函数
let counts = fruits.map(fruit)
// [Optional(5), Optional(6), Optional(6)]
print(counts)

接下来我们实现一下自己的map，代码如下

extension Array {
    // 定义 BeforeType 为之前的类型 BecomeType 为最终转化成的类型
    // 这里我们需要接受一个transform闭包，来定义我们转化的规则
    func myMap<BeforeType, BecomeType>(transform:
        (BeforeType) -> (BecomeType)) -> [BecomeType] {
        // 定义一个转化后类型的空数组
        var output: [BecomeType] = []
        for item in self {
            // 通过闭包转化类型
            let transformed =
                transform(item as! BeforeType)
            // 添加到之前的创建的空数组
            output.append(transformed)
        }
        return output
    }
}

let fruits = ["apple", "banana", "orange"]
// 将字符串转换成字符串的长度
func fruit(fruit: String) -> Int? {
    let length = fruit.characters.count
    guard length > 0 else {
        return nil
    }
    return length
}
// map接受一个定义规则的函数
let counts = fruits.myMap(fruit)
// 我们可以看到返回的结果是一样的
// [Optional(5), Optional(6), Optional(6)]
print(counts)
// 由此可以看出map内部就是这样实现的

MyReduce

首先我们先看看使用Swift中原有reduce的实现，代码如下

var numArray = [1, 2, 3, 4, 5, 6]
// reduce有两个参数，第一个是用来表示第一次“合并”之前的初始值。因为我们要求和，所以它是0。
// 第二个参数combine是一个闭包，用来表示“合并”的规则。
// 它的第一个参数是“每一次合并前”的初始值，第二个参数是要“合并”进来的对象。
// 在我们的例子里，$0是0，$1表示数组中的每一个对象。
let sum = numArray.reduce(0, combine: { $0 + $1 })
// 21
print(sum)

接下来我们实现一下自己的reduce

extension Array {
    // 由于最终“合并”出来的结果有可能和参与合并的值类型不同
    //（例如：把一个整数数组拼接成一个字符串）
    // 所以myReduce需要两个泛型类型
    // 一个表示“合并”后的类型BecomeType
    // 一个表示参与“合并”的类型BeforeType
    // myReduce接受两个参数，initial用来表示整个合并前的初始值，它的类型是BecomeType
    // combine是一个闭包，用来表示合并的规则。
    // 每一次调用，都是把当前要合并的值合并到上一次的合并结果里，然后把新的合并结果返回
    func myReduce<BecomeType, BeforeType>(initial: BecomeType,
                  combine: (BecomeType, BeforeType) -> BecomeType) -> BecomeType {
        var seed = initial
        
        for item in self {
            seed = combine(seed, item as! BeforeType)
        }
        // 最后，当所有的合并都完成之后，myReduce返回最终的值
        return seed
    }
}

var numArray = [1, 2, 3, 4, 5, 6]
let sum = numArray.myReduce(0, combine: { $0 + $1 })
// 21
print(sum)

---

好了，Swift中泛型的介绍就到这了，接下来我会写一些有关POP和Reactive Programming方面的介绍，欢迎大家持续关注我，这次我不会脱更那么久了哦～
点击关注---->MelodyZhy