Swift中的类型抹消

2018-02-27 11:15:17来源:https://www.jianshu.com/p/5a79557ac98f作者:天天学搬砖人点击

分享


首先献上本文的Demo


标准库中的类型抹消

不知道大家有没有听说过Swift中的类型抹消,所谓类型抹消就是不将某实例的真实类型暴露出去,对外只暴露一个必要的类型。举个:当我们编写一个class或者struct并实现了一个协议,当我们对外提供该实例时,只想让外界知道这个东西实现了该协议,可是又不想让外界知道实现了这个协议的class或者struct是哪一个类型的,这时我们就需要用到类型抹消,其实在Swift的标准库就有这样的东西。


struct FibsIterator: IteratorProtocol {
var status = (0, 1)
mutating func next() -> Int? {
guard status.0 < 100 else { return nil }
let num = status.0
self.status = (status.1, status.0 + status.1)
return num
}
}
struct SquareIterator: IteratorProtocol {
var status = 1
mutating func next() -> Int? {
guard status < 100 else { return nil }
defer {
status = status * 2
}
return status
}
}
// fibsIterator的type: AnyIterator<Int>
let fibsIterator = AnyIterator(FibsIterator())
// squareIterator的type: AnyIterator<Int>
let squareIterator = AnyIterator(SquareIterator())
// anyIteratorArray的type: [AnyIterator<Int>]
let anyIteratorArray = [fibsIterator, squareIterator]
// fibsSequence的type: AnySequence<Int>
let fibsSequence = AnySequence { return FibsIterator() }
// 这里因为实现一个Collection协议比较麻烦就直接用数组好了
// c的type: AnyCollection<Int>
let c = AnyCollection(Array<Int>())


关于IteratorProtocolSequenceCollection这里不做介绍......



在我们实现了一个斐波拉契的迭代器后,我们想让外界使用该迭代器来产生斐波拉契序列,可是我们又不想让外界知道我这个东西是是用FibsIterator这个struct来实现的。于是我们就用AnyIteratorAnySequenceAnyCollection来包装它,外界使用者只知道迭代这个东西时是产生一个Int类型的迭代器、序列或集合。这样我们就将FibsIterator的类型给隐藏了。


尝试造轮子

既然我们知道类型抹消这个小技巧,那我们就来学造轮子。首先我们就模仿标准库来实现一个抹消类型的迭代器,首先我们先按照上面的套路定义一个协议和实现两个迭代器:


protocol MyIteratorProtocol {
associatedtype Element
mutating func next() -> Self.Element?
}
struct FibsIterator: MyIteratorProtocol {
var status = (0, 1)
mutating func next() -> Int? {
guard status.0 < 100 else { return nil }
let num = status.0
self.status = (status.1, status.0 + status.1)
return num
}
}
struct SquareIterator: MyIteratorProtocol {
var status = 1
mutating func next() -> Int? {
guard status < 100 else { return nil }
defer {
status = status * 2
}
return status
}
}

然后我们来实现迭代器包装的盒子,对外只暴露迭代器next()方法放回的类型(这里以Int类型为例),而不暴露实现的迭代器类型,一开始我们可能会写出这样的代码:


class IteratorBox<I: MyIteratorProtocol> {
var iterator: I
init(_ iterator: I) {
self.iterator = iterator
}
func next() -> I.Element? {
return iterator.next()
}
}
// fibsIteratorBox的type: IteratorBox<FibsIterator>
let fibsIteratorBox = IteratorBox(FibsIterator())
// squareIteratorBox的type: IteratorBox<SquareIterator>
let squareIteratorBox = IteratorBox(SquareIterator())
// 报错!类型不同,所以Boxs需要转成[Any]
let Boxs = [fibsIteratorBox, squareIteratorBox]❌

在这里出现了两个问题:
第一个问题是我们定义的泛型I直接就暴露出去了,这样就违背了我们的初衷,我们只想要外界看到的是I.Element的类型,而不是暴露I的类型。
第二个问题是,用数组存放这些IteratorBox时,由于泛型不相同而报错。


方法一:通过属性保存迭代器方法的实现

首先我们明确知道为了防止实现MyIteratorProtocol的类型被暴露,IteratorBox的泛型应为MyIteratorProtocolElement类型,而不是MyIteratorProtocol的类型。其次我们也必须要IteratorBox实现MyIteratorProtocol协议,确保IteratorBox包含完整的功能。


struct IteratorBox<A>: MyIteratorProtocol {
private var nextIMP: () -> A?
init<I: MyIteratorProtocol>(_ iterator: I) where I.Element == A {
var iteratorCopy = iterator // Swift中参数被隐式声明为let
self.nextIMP = { iteratorCopy.next() }
}
func next() -> A? {
return nextIMP()
}
}
// fibsIteratorBox的type: IteratorBox<Int>
let fibsIteratorBox = IteratorBox(FibsIterator())
// squareIteratorBox的type: IteratorBox<Int>
let squareIteratorBox = IteratorBox(SquareIterator())
// Boxs的type: [IteratorBox<Int>]
let Boxs = [fibsIteratorBox, squareIteratorBox]

这样的方法实现起来是非常简单方便的,也实现了标准库中同样的效果。但这样只适合方法较少的类型,因为MyIteratorProtocol每多一个方法就要多一个属性来保存,而且在init方法中也需要编写额外的代码。
MyIteratorProtocol方法数量多时我们只能像上面那样保存实现MyIteratorProtocol的迭代器,通过迭代器来调用。但是上面造轮子处不是尝试过了吗?而且还问题多多呢...所以我们来看看接下来的方法。


方法二:利用面向对象中的继承和多态特性

首先我们还是要明确刚才提及的需求。我们实现的IteratorBox的泛型应为MyIteratorProtocolElement类型,而为了保存实现MyIteratorProtocol的迭代器我们又要将泛型约束为实现MyIteratorProtocol的类型,这样就会造成冲突。既然一个类不能同时满足这两个类型,那我们就用两个类来实现好了。


class IteratorBox<A>: MyIteratorProtocol {
func next() -> A? {
fatalError("This method is abstract, you need to implement it!")
}
}

首先我们让IteratorBox实现MyIteratorProtocol中的所有方法,而在方法的实现里我们仅仅让它崩溃。接下来我们实现一个IteratorBoxHelper来保存迭代器,并实现协议里的方法:


class IteratorBoxHelper<I: MyIteratorProtocol> {
var iterator: I
init(_ iterator: I) {
self.iterator = iterator
}
func next() -> I.Element? {
return iterator.next()
}
}

最后我们让IteratorBoxHelper继承自IteratorBox


class IteratorBoxHelper<I: MyIteratorProtocol>: IteratorBox<I.Element> {
var iterator: I
init(_ iterator: I) {
self.iterator = iterator
}
override func next() -> I.Element? {
return iterator.next()
}
}

继承IteratorBox时我们将泛型A的类型约束为IteratorBoxHelperIElement的类型。
我们通过IteratorBoxHelper来包装迭代器后,将该类型声明为IteratorBox,也就所谓的向上转型(将子类类型声明为父类类型),然后我们来调用这些迭代器,调用方法时会根据多态性的特点调用真实类型的方法。


// fibsIteratorBox的type: IteratorBox<Int>
let fibsIteratorBox: IteratorBox = IteratorBoxHelper(FibsIterator())
// squareIteratorBox的type: IteratorBox<Int>
let squareIteratorBox: IteratorBox = IteratorBoxHelper(SquareIterator())
// Boxs的type: [IteratorBox<Int>]
let Boxs = [fibsIteratorBox, squareIteratorBox]
print("调用fibsIteratorBox的next方法")
while let num = fibsIteratorBox.next() {
print(num)
}
print("调用squareIteratorBox的next方法")
while let num = squareIteratorBox.next() {
print(num)
}

包装后不再具有值语义

在这里提一点是,我们的FibsIteratorSquareIterator都是struct,具有值语义,而当我们将它赋值给另一个变量后再迭代就会进行写时复制:


var fib1 = FibsIterator()
print(fib1.next()!) // 0
print(fib1.next()!) // 1
print(fib1.next()!) // 1
var fib2 = fib1
print(fib1.next()!) // 2
print(fib1.next()!) // 3
print(fib2.next()!) // 2
print(fib2.next()!) // 3

对于方法一,虽然IteratorBox的类型和标准库中的AnyIterator同为struct,当它们两个都并不具备写时复制的特性,IteratorBox的闭包属性捕获了iteratorCopy,即使赋值给另一个变量,闭包属性也还是引用用一个iteratorCopy
对于方法二,由于IteratorBoxIteratorBoxHelper都是class类型,那么就会变成了引用语义,给另一变量赋值时只是指针拷贝:


let fibsIteratorBox: IteratorBox = IteratorBoxHelper(FibsIterator())
print(fibsIteratorBox.next()!) // 0
print(fibsIteratorBox.next()!) // 1
print(fibsIteratorBox.next()!) // 1
let fibsBox2 = fibsIteratorBox
print(fibsIteratorBox.next()!) // 2
print(fibsIteratorBox.next()!) // 3
print(fibsBox2.next()!) // 5
print(fibsBox2.next()!) // 8


至此我们就成功模仿了Swift标准库中AnyIterator的实现。如有错漏,请多指教。









最新文章

123

最新摄影

闪念基因

微信扫一扫

第七城市微信公众平台