持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第9天，点击查看活动详情

Swift基础语法文章汇总

本文将泛型的常见设置方式进行讲解，以及协议使用关联类型的问题和解决

主要内容：

泛型认识

关联类型

类型约束

泛型的实际使用

不透明类型

1. 泛型认识

泛型基本上和Java是一样的，可以用在函数，也可以用在类型上，泛型通过类型参数化，共用类型，提高代码复用率，泛型实现的本质是将类型作为参数传入到函数中。需要注意是否显式写泛型取决于是否已经明确类型

用在函数

代码：

//用在函数
//定义一个交换函数，通过元组交换的，定义T为泛型
func swapValues<T>(_ a: inout T, _ b: inout T) {
    (a, b) = (b, a)
}
//分别交换int、float、struct类型
//传参时就可以决定类型，所以这里的swapValues后面不需要加<T>
var i1 = 10
var i2 = 20
swapValues(&i1, &i2)
    
var d1 = 10.0
var d2 = 20.0
swapValues(&d1, &d2)
    
struct Date {
    var year = 0, month = 0, day = 0
}
var dd1 = Date(year: 2011, month: 9, day: 10)
var dd2 = Date(year: 2012, month: 10, day: 11)
swapValues(&dd1, &dd2)
print(dd1)
print(dd2)
    
//将函数赋给一个变量
var n1 = 10
var n2 = 20
let fn: (inout Int, inout Int) -> () = swapValues
fn(&n1, &n2)
print(n1,n2)//20 10

说明：

泛型的含义以及定义和Java一样
但是这里调用时不需要传入泛型，比如不能swapValues< Int >，因为传入参数时就可以确定类型
赋值给变量需要设置类型，因为此时的swapValues传入的参数就是Int，所以这里需要设置类型

用在类型

代码：

//用在类型
//自定义一个栈，实现简单的出栈入栈,使用elements数组来存储元素
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
    }
}
//这里没有传参，所以需要增加<>类型
var intStack = Stack<Int>()
intStack.push(1)
print(intStack.size())
intStack.pop()
print(intStack.size())
var stringStack = Stack<String>()

说明：

需要注意的是这里可以加上< Int >约定类型，因为没有传入参数无法预知类型
如果直接调用Init传入参数来创建对象时，就不需要加上<>了

用在枚举

代码：

//用在枚举
enum Score<T> {
    case point(T)
    case grade(String)
}
//这里虽然使用了grade，没使用point，但是只要创建这个枚举，就应该传入泛型类型
let score = Score<Int>.grade("A")

说明：

这里虽然没有用用到point，但是也要加上泛型，因为枚举要确定内存结构

2. 关联类型

协议通过关联类型来实现泛型，关联类型可以给协议中用到的类型定义一个占位名称，使用关键字associatedtype来定义。

代码：

/*
 2、关联类型
 其实就是协议的泛型
 */
//创建一个泛型，定义了一个类型Element，该类型遵守Equatable协议
protocol Stackable {
    associatedtype Element : Equatable
}
func test2() {
    //创建一个类，泛型类型必须遵守该协议，并且将该类型赋值给Element
    class Stack<E : Equatable> : Stackable {
        typealias Element = E
    }
}

说明：

泛型可以增加约束，这里是遵守Equatable协议的元素作为泛型
因此在类中想要给其赋值，这个E也必须遵守Equatable协议
通过typealias Element = E 把泛型设置上

3. 类型约束

代码：

/*
 3、类型约束
 */
//通过where可以增加类型的约束
/*
 约束如下：
 1. S1、S2 都是泛型，
 2. 泛型都遵守协议Stackable
 3. S1和S2的关联类型要相等，这个Element是在类Stack中赋值的，他们要赋值相同
 4. S1的关联类型必须遵守Hashable协议
 */
func equal<S1: Stackable, S2: Stackable>(_ s1: S1, _s2: S2) -> Bool where S1.Element == S2.Element, S1.Element : Hashable {
    return false
}

var stack1 = Stack<Int>()
var stack2 = Stack<Int>()
var stack3 = Stack<String>()
print(equal(stack1, _s2: stack2))
print(equal(stack1, _s2: stack3))

说明：

S1、S2 都是泛型，且泛型都遵守协议Stackable
S1和S2的Element要相等，这个Element是在类Stack中赋值的，他们要赋值相同
S1的关联类型必须遵守Hashable协议

4. 泛型的实际使用

4.1 代码优化

代码：

/*
 4、应用：代码优化
 */
protocol Runnable {}
class Person : Runnable {}
class Car : Runnable {}

//这里返回值只要写上Runnable，那么返回的只要是遵守该协议的就都可以
//否则每个类型都写一个方法，代码冗余
func get(_ type: Int) -> Runnable {
    if type == 0 {
        return Person()
    }
    return Car()
}

var r1 = get(0)
var r2 = get(1)

说明：

一个类要返回多种类型的方法，就可以使用

4.2 问题

协议中有关联类型

代码：

报错.webp

说明：

在协议中有关联类型，如果在使用该属性时么有设置该关联类型，就会报错

4.3 解决

4.3.1 使用泛型

代码：

/*
 4、应用：代码优化
 */
protocol Runnable {
    associatedtype Speed
    var speed: Speed { get }
}
class Person : Runnable {
    var speed: Double { 0.0 }
}
class Car : Runnable {
    var speed: Int { 0 }
}

//这里返回值只要写上Runnable，那么返回的只要是遵守该协议的就都可以
//否则每个类型都写一个方法，代码冗余
/*
 增加泛型
 1、方法中传入泛型，该类型必须遵守Runnable协议
 2、最后返回这个类型
 3、当然在返回的时候就需要判断一下是否遵守该协议
 */
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)

说明：

这里可以明确泛型的类型，这样就可以解决
明确返回的类型是Person或Car，这样泛型的Speed就是明确的
只不过这里在返回时需要强制转换类型为T

4.3.2 使用不透明类型

代码：

/*
 5、不透明类型
 */
 //这里可以使用some来
func get(_ type: Int) -> some Runnable {
    return Person()
}
var r1 = get(0)
var r2 = get(1)

说明：

不透明在于这里外界只知道返回一个遵守runnable协议的类，而不知道具体的类
得到的类型所能看到的信息是Runnable，Person类中的信息看不到
只能返回一种类型
some除了用在返回值类型上，一般还可以用在属性类型上

Swift基础语法（十一）泛型

1. 泛型认识

用在函数

用在类型

用在枚举

2. 关联类型

3. 类型约束

4. 泛型的实际使用

4.1 代码优化

4.2 问题

4.3 解决

4.3.1 使用泛型

4.3.2 使用不透明类型