0%

swift泛型笔记

泛型可以让代码处理类型更加灵活,在某些场景下可以很大程度的重用代码,泛型是什么,使用泛型的好处,这里不多说,网上有很多文章介绍的很详细,这里只讨论用法,Swift的泛型与其他语言有些类型,又有些不一样,搜了一下发现,网上的文章只描述了一点,并不全面,看完后依然没能很全面的说明泛型的用法,在这里记录完整的用法

定义泛型

swift的泛型定义方式有两种,一种通过<T>指定泛型参数,而在属性或方法,使用指定的泛型类型,下面是一个泛型方法的声明

泛型方法

/// 交换两个同类型的变量
func swap<T>(a: inout T, b: inout T) {
let c = a
a = b
b = c
}
var (a, b) = (2, 1)

swap(&a, &b)
print(a, b) // 1, 2

swap(&a, &b)
print(a, b) // 2, 1

泛型类

上面是泛型方法的定义,如果在类里面,可以对类声明泛型

class Test<T> {
/// 泛型属性
var testObj: T?

/// 泛型方法,可以直接使用类的泛型参数T
func swap<T>(a: inout T, b: inout T) {
let c = a
a = b
b = c
}

/// 方法的泛型定义可以不依赖于类的泛型参数
func swap2<TK>(a: inout TK, b: inout TK) {
let c = a
a = b
b = c
}
}

// 属性
let t = Test<Int>()
t.testObj = 12
print(t.testObj) // 12

var a: Int? = 2
var b: Int? = 1
t.swap(a: &a, b: &b)
print(a, b) // 1, 2

var s1: String? = "a"
var s2: String? = "b"
t.swap2(a: &s1, b: &s2)
print(s1, s2) // b, a

泛型参数

泛型可以支持多个类型参数,在声明处用逗号分开

class Test {
/// 多个泛型参数
func test<T1, T2>(t1: T1, t2: T2) -> Int {
print("t1: \(t1), t2: \(t2)")
return 1
}
}

let t = Test()
let result = t.test(t1: NSObject(), t2: "abc")

泛型约束

类型约束定义在泛型声明处,支持类约束和protocol约束,如下

protocol Run {
func run()
}

protocol Fly {
func fly()
}

/// 单协议约束
func test<T: Run>(animal: T) {
animal.run()
}

/// 类型和多协议约束
func test<T: NSObject & Fly & Run>(bird: T) {
bird.fly()
bird.run()
}

泛型可以用在方法参数,方法返回值,属性上

协议泛型

除了类,结构体和枚举也支持泛型,用法与类一样,但是协议protocol不能像上面一样使用
协议只能通过关联类型associatedtype来实现泛型的功能,相当于泛型声明为协议的成员,而泛型的成员在实现的时候指定

protocol Write {
/// 关联类型Element,相当于上面的T
associatedtype Element
func write(_ element: Element)
}

class File: Write {
// 在实现关联类型的协议的时候,需要指定关联类型
typealias Element = String

// 实现协议方法
func write(_ element: File.Element) {
print(element)
}
}

关联类型的约束

关联类型的约束与普通泛型约束一样,在声明的地方后面添加,通过逗号隔开

 protocol Write {
associatedtype Element: NSObject, Encodable
func write(_ element: Element)
}

关联自身类型

protocol利用associatedtype关联自身类型

protocol Equalable {
func equal(_ a: Self) -> Bool
}

class Test: Equalable {
var id: Int = 0

init(id: Int) {
self.id = id
}

func equal(_ a: Test) -> Bool {
return self.id == a.id
}
}

let a = Test(id: 1)
let b = Test(id: 2)
a.equal(b) // false

associatedtype冲突

associatedtype有另一个问题没有解决,就是类型冲突,如下

protocol Read {
associatedtype Element
func read() -> Element
}
protocol Write {
associatedtype Element
func write(a: Element)
}

// 两个Element名字相同,无法指定
class ReadWrite: Read, Write {
func read() -> Int {
return 5
}
func write(a: String) {
print("writing \(a)")
}
}

在stackoverflow上有个不完美的解决方案:
https://stackoverflow.com/questions/37736457/protocol-with-same-associated-type-name

protocol ReadInt: Read {
associatedtype Element = Int
}
protocol WriteString: Write {
associatedtype Element = String
}

class ReadWrite: ReadInt, WriteString {
func read() -> Int {
return 5
}
func write(a: String) {
print("writing \(a)")
}
}

关于associatedtype

对于其他语言大多都使用直接指定类型<T>的方式声明泛型,而swift为什么还要搞出一个associatedtype呢,这篇文章有分析:http://www.cocoachina.com/swift/20160726/17188.html

使用关联类型,类似于类型当成成员属性使用,可以解耦依赖,如果需要使用对象的关联的类型,而类型与当前对象并没有直接关系,则通过成员的关联类型引用可以避免直接依赖对象类型,如下例子:机动车(Automobile)、燃料(Fuel)、尾气(Exhaust)

/// 机动车
public protocol Automobile {
associatedtype FuelType
associatedtype ExhaustType
func drive(fuel: FuelType) -> ExhaustType
}

/// 燃料
public protocol Fuel {
associatedtype ExhaustType
func consume() -> ExhaustType
}

/// 尾气
public protocol Exhaust {
func emit()
}

实现

public struct UnleadedGasoline: Fuel {
public func consume() -> E {
print("consuming unleaded gas...")
return E()
}
}

public struct CleanExhaust: Exhaust {
public func emit() {
print("this is some clean exhaust...")
}
}

public class Car: Automobile {
public func drive(fuel: F) -> E {
return fuel.consume()
}
}

实际依赖关系:
机动车 -> 燃料
燃料 -> 尾气

但是代码有个问题是在定义Car的时候,必须声明尾气的类型E,而实际上机动车是不依赖于尾气的类型的,尾气的类型取决于燃料,如果Car支持两种燃料FuelA和FuelB,而两种燃料产生的尾气E1和E2,drive方法无法同时满足,只能定义两个方法

public class Car: Automobile {

public func drive(fuel: F1) -> E1 {
return fuel.consume()
}
public func drive(fuel: F2) -> E2 {
return fuel.consume()
}
}

如果使用关联类型的话可以解决这个问题,把尾气关联到燃料上

public class Car: Automobile {
public func drive(fuel: F) -> F.ExhaustType {
return fuel.consume()
}
}

以上就是Swift泛型的全部要点