Swift如何使用类型擦除及自定义详解

2023-09-07 16:40:05 65

前言

在Swift的世界中，如果我们将协议称之为国王，那么泛型则可以视作皇后，所谓一山不容二虎，当我们把这两者结合起来使用的时候，似乎会遇到极大的困难。那么是否有一种方法，能够将这两个概念结合在一起，以便让它们成为我们前进道路上的垫脚石，而不是碍手碍脚的呢？答案是有的，这里我们将会使用到类型擦除(TypeErasure)这个强大的特性。

你也许曾听过类型擦除，甚至也使用过标准库提供的类型擦除类型如AnySequence。但到底什么是类型擦除?如何自定义类型擦除?在这篇文章中，我将讨论如何使用类型擦除以及如何自定义。在此感谢LorenzoBoaro提出这个主题。

有时你想对外部调用者隐藏某个类的具体类型，或是一些实现细节。在一些情况下，这样做能防止静态类型在项目中滥用，或者保证了类型间的交互。类型擦除就是移除某个类的具体类型使其变得更通用的过程。

协议或抽象父类可作为类型擦除简单的实现方式之一。例如NSString就是一个例子，每次创建一个NSString实例时，这个对象并不是一个普通的NSString对象，它通常是某个具体的子类的实例，这个子类一般是私有的，同时这些细节通常是被隐藏起来的。你可以使用子类提供的功能而不用知道它具体的类型，你也没必要将你的代码与它们的具体类型联系起来。

在处理Swift泛型以及关联类型协议的时候，可能需要使用一些高级的内容。Swift不允许把协议当做具体的类型来使用。例如，如果你想编写一个方法，它的参数是一个包含了Int的序列，那么下面这种做法是不正确的：

funcf(seq:Sequence){...

你不能这样使用协议类型，这样会在编译时报错。但你可以使用泛型来替代协议，解决这个问题：

funcf(seq:S)whereS.Element==Int{...

有时候这样写完全可以，但有些地方还存在一些比较麻烦的情况，通常你不可能只在一个地方添加泛型:一个泛型函数对其他泛型要求更多…更糟糕的是，你不能将泛型作为返回值或者属性。这就跟我们想的有点不一样了。

funcg()->SwhereS.Element==Int{...

我们希望函数g能返回任何符合的类型，但上面这个不同，它允许调用者选择他所需要的类型，然后函数g来提供一个合适的值。

Swift标准库中提供了AnySequence来帮助我们解决这个问题。AnySequence包装了一个任意类型的序列，并擦除了它的类型。使用AnySequence来访问这个序列，我们来重写一下函数f与函数g：

funcf(seq:AnySequence){...

funcg()->AnySequence{...

泛型部分不见了，同时具体的类型也被隐藏起来了。由于使用了AnySequence包装具体的值，它带来了一定的代码复杂性以及运行时间成本。但是代码却更简洁了。

Swift标准库中提供了很多这样的类型，如AnyCollection、AnyHashable及AnyIndex。这些类型在你自定义泛型或协议的时候非常的管用，你也可以直接使用这些类型来简化你的代码。接下来让我们探索实现类型擦除的多种方式吧。

基于类的类型擦除

有时我们需要在不暴露类型信息的情况下从多个类型中包装一些公共的功能，这听起来就像是父类-子类的关系。事实上我们的确可以使用抽象父类来实现类型擦除。父类提供API接口，不用去管谁来实现。而子类根据具体的类型信息实现相应的功能。

接下来我们将使用这种方式来自定义AnySequence，我们将其命名为MAnySequence：

classMAnySequence:Sequence{

这个类需要一个iterator类型作为makeIterator返回类型。我们必须要做两次类型擦除来隐藏底层的序列类型以及迭代器的类型。我们在MAnySequence内部定义了一个Iterator类，该类遵循着IteratorProtocol协议，并在next()方法中使用fatalError抛出异常。Swift本身不支持抽象类型，但这样也够了:

classIterator:IteratorProtocol{
funcnext()->Element?{
fatalError("Mustoverridenext()")
}
}

MAnySequence对makeIterator方法实现也差不多。直接调用将抛出异常，这用来提示子类需要重写这个方法:

funcmakeIterator()->Iterator{
fatalError("MustoverridemakeIterator()")
}
}

这样就定义了一个基于类的类型擦除的API，私有的子类将来实现这些API。公共类通过元素类型参数化，但私有实现类由它包装的序列类型进行参数化:

privateclassMAnySequenceImpl:MAnySequence{

MAnySequenceImpl需要一个继承于Iterator的子类:

classIteratorImpl:Iterator{

IteratorImpl包装了序列的迭代器:

varwrapped:Seq.Iterator

init(_wrapped:Seq.Iterator){
self.wrapped=wrapped
}

在next方法中调用被包装的序列迭代器：

overridefuncnext()->Seq.Element?{
returnwrapped.next()
}
}

相似地，MAnySequenceImpl包装一个序列：

varseq:Seq

init(_seq:Seq){
self.seq=seq
}

从序列中获取迭代器，然后将迭代器包装成IteratorImpl对象返回，这样就实现了makeIterator的功能。

overridefuncmakeIterator()->IteratorImpl{
returnIteratorImpl(seq.makeIterator())
}

}

我们需要一种方法来实际创建这些东西：对MAnySequence添加一个静态方法，该方法创建一个MAnySequenceImpl实例，并将其作为MAnySequence类型返回给调用者。

extensionMAnySequence{
staticfuncmake(_seq:Seq)->MAnySequencewhereSeq.Element==Element{
returnMAnySequenceImpl(seq)
}
}

在实际开发中，我们可能会做一些额外的操作来让MAnySequence提供一个初始化方法。

我们来试试MAnySequence：

funcprintInts(_seq:MAnySequence){
foreltinseq{
print(elt)
}
}

letarray=[1,2,3,4,5]
printInts(MAnySequence.make(array))
printInts(MAnySequence.make(array[1..<4]))

完美!

基于函数的类型擦除

有时我们希望对外暴露支持多种类型的方法，但又不想指定具体的类型。一个简单的办法就是，存储那些签名仅涉及到我们想公开的类型的函数，函数主体在底层已知具体实现类型的上下文中创建。

我们一起看看如何运用这种方法来设计MAnySequence，与前面的实现很类似。它是一个结构体而非类，这是因为它仅仅作为容器使用，不需要有任何的继承关系。

structMAnySequence:Sequence{

跟之前一样，MAnySequence也需要一个可返回的迭代器（Iterator）。迭代器同样被设计为结构体，并持有一个参数为空并返回Element?的存储型属性，实际上这个属性是一个函数，被用于IteratorProtocol协议的next方法中。接下来Iterator遵循IteratorProtocol协议，并在next方法中调用函数:

structIterator:IteratorProtocol{
let_next:()->Element?

funcnext()->Element?{
return_next()
}
}

MAnySequence与Iterator很相似：持有一个参数为空返回Iterator类型的存储型属性。遵循Sequence协议并在makeIterator方法中调用这个属性。

let_makeIterator:()->Iterator

funcmakeIterator()->Iterator{
return_makeIterator()
}

MAnySequence的构造函数正是魔法起作用的地方，它接收任意序列作为参数:

init(_seq:Seq)whereSeq.Element==Element{

接下来需要在构造函数中包装此序列的功能:

_makeIterator={

如何生成迭代器？请求Seq序列生成：

variterator=seq.makeIterator()

接下来我们利用自定义的迭代结构体包装序列生成的迭代器，包装后的_next属性将会在迭代器协议的next()方法中被调用:

returnIterator(_next:{iterator.next()})
}
}
}

接下来展示如何使用MAnySequence：

funcprintInts(_seq:MAnySequence){
foreltinseq{
print(elt)
}
}

letarray=[1,2,3,4,5]
printInts(MAnySequence(array))
printInts(MAnySequence(array[1..<4]))

正确运行，太棒了！

当需要将小部分功能包装为更大类型的一部分时，这种基于函数的类型擦除方法特别实用，这样做就不需要有单独的类来实现被擦除类型的这部分功能了。

比方说你现在想要编写一些适用于各种集合类型的代码，但它真正需要能够对这些集合执行的操作是获取计数并执行从零开始的整数下标。如访问tableView数据源。它可能看起来像这样：

classGenericDataSource{
letcount:()->Int
letgetElement:(Int)->Element

init(_c:C)whereC.Element==Element，C.Index==Int{
count={c.count}
getElement={c[$0-c.startIndex]}
}
}

GenericDataSource其他代码可通过调用count()或getElement()来操作传入的集合。且不会让集合类型破坏GenericDataSource泛型参数。

结束语

类型擦除是一种非常有用的技术，它可用来阻止泛型对代码的侵入，也可用来保证接口简单明了。通过将底层类型包装起来，将API与具体的功能进行拆分。这可以通过使用抽象的公共超类和私有子类或将API包装在函数中来实现。对于只需要一些功能的简单情况，基于函数类型擦除极其有效。

Swift标准库提供了几种可直接利用的类型擦除类型。如AnySequence包装一个Sequence，正如其名，AnySequence允许你对序列迭代而无需知道序列具体的类型。AnyIterator也是类型擦除的类型，它提供一个类型擦除的迭代器。AnyHashable也同样是类型擦除的类型，它提供了对Hashable类型访问功能。Swift还有很多基于集合的擦除类型，你可以通过搜索Any来查阅。标准库中也为CodableAPI设计了类型擦除类型:KeyedEncodingContainer和KeyedDecodingContainer。它们都是容器协议类型包装器，可用来在不知道底层具体类型信息的情况下实现Encode和Decode。

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对毛票票的支持。

作者：MikeAsh，原文链接，原文日期：2017-12-18

译者：rsenjoyer；校对：Yousanflics，numbbbbb；定稿：Forelax

Swift如何使用类型擦除及自定义详解

热门推荐

随机推荐