协议 (Protocol) 是 Swift 语言中非常强大而灵活的一个特性。而其中的关联类型就是 Swift 协议灵活的一个表现。
关联类型
@available(OSX 10.15, iOS 13, tvOS 13, watchOS 6, *)
public protocol Identifiable {
associatedtype ID: Hashable
var id: Self.ID { get }
}
我们首先来看 iOS 13 新增的 Identifiable
,它声明了一个遵循 Hashable
的关联类型 ID
,并且把变量 id
声明为 ID
类型。这么做的好处是实现 Identifiable
协议的类型,它的 id
变量可以是任何遵循 Hashable
协议的类型。例如:
struct MyIdType: Hashable {
let id: String
}
struct A: Identifiable {
let id: String
}
struct B: Identifiable {
let id: Int
}
struct C: Identifiable {
let id: MyIdType
}
A
、 B
和 C
都实现了 Identifiable
协议,其中 C
的 id
类型是自定义的遵循 Hashable
协议的类型。
其实,上面的代码是一个简写的形式,如果把代码写全,应该明确指定 ID
的类型:
struct A: Identifiable {
typealias ID = String
let id: String
}
struct B: Identifiable {
typealias ID = Int
let id: Int
}
struct C: Identifiable {
typealias ID = MyIdType
let id: MyIdType
}
这就是 Swift 协议的关联类型,我们也可以把有关联类型的协议看做是泛型协议。因为我们传什么类型给关联类型,他就是什么类型,与泛型一致。
约束
关联类型非常灵活,但有时候不想让它这么灵活,这时可以使用约束来限制它。
假设有一个 Apple Store,里面售卖 iPhone、Mac 和 Apple Watch。我们要求里面的产品具有相同的 logo。
接下来,我们用代码一步一步演示。
首先定义一个 AppleProduct
,描述 Apple 产品,代码如下:
protocol AppleProduct {
associatedtype LogoType
var logo: LogoType { get }
}
要求每个产品有一个 logo
属性。
接下来,定义 AppleStore
,描述 Apple Store,先把它写成:
protocol AppleStore {
associatedtype IphoneType: AppleProduct
associatedtype MacType: AppleProduct
associatedtype WatchType: AppleProduct
var iphones: [IphoneType] { get }
var macs: [MacType] { get }
var watches: [WatchType] { get }
}
从上面的代码上看,所有的产品都是 AppleProduct
类型,这个没错,但是每一类产品的 logo 可以是不同的。例如 IphoneType
的 logo 可以是一个字符串 Apple
,MacType
的 logo 可以是一个被咬了一口的苹果图像。
那如何保证所有产品的 logo 是相同的?这时我们就必须用到约束,使用 where
关键字。把代码改造如下:
protocol AppleStore {
associatedtype IphoneType: AppleProduct
// 限制 MacType 的 LogoType 等于 IphoneType 的 LogoType
associatedtype MacType: AppleProduct where MacType.LogoType == IphoneType.LogoType
// 限制 WatchType 的 LogoType 等于 IphoneType 的 LogoType
associatedtype WatchType: AppleProduct where WatchType.LogoType == IphoneType.LogoType
var iphones: [IphoneType] { get }
var macs: [MacType] { get }
var watches: [WatchType] { get }
}
通过这两个限制,AppleStore
的三种产品的 logo 都是相同的了。
下面是 AppleStore 的具体实现:
struct Iphone: AppleProduct {
let logo: String
}
struct Mac: AppleProduct {
let logo: String
}
struct Watch: AppleProduct {
let logo: String
}
struct Store: AppleStore {
var iphones: [Iphone] = []
var macs: [Mac] = []
var watches: [Watch] = []
}
如果把 Iphone
、 Mac
和 Watch
的其中一个 logo 类型改为其他类型,Store
就无法遵循 AppleStore
协议。
声明协议类型的变量
无关联类型协议的变量
如果看过 Kickstarter 的源码,你应该会熟悉其中的 ViewModel 的写法。它的模板结构如下:
protocol AppDelegateViewModelInputs {
func applicationDidBecomeActive()
func applicationWillEnterForeground()
}
protocol AppDelegateViewModelOutputs {
var pushTokenSuccessfullyGenerated: Signal { get }
}
protocol AppDelegateViewModelType {
var inputs: AppDelegateViewModelInputs { get }
var outputs: AppDelegateViewModelOutputs { get }
}
final class AppDelegateViewModel: AppDelegateViewModelType, AppDelegateViewModelInputs, AppDelegateViewModelOutputs {
init() {}
private let applicationDidBecomeActiveProperty = MutableProperty(())
func applicationDidBecomeActive() {
applicationDidBecomeActiveProperty.value = ()
}
private let applicationWillEnterForegroundProperty = MutableProperty(())
func applicationWillEnterForeground() {
applicationWillEnterForegroundProperty.value = ()
}
let pushTokenSuccessfullyGenerated: Signal
var inputs: AppDelegateViewModelInputs { return self }
var outputs: AppDelegateViewModelOutputs { return self }
}
这里以 AppDelegate
的 ViewModel 为例,AppDelegateViewModelType
协议规定了 inputs
和 outputs
两个变量,并且类型都是协议类型,所以使用时就能直接调用协议规定的方法或者变量,例如:
viewModel.inputs.applicationDidBecomeActive()
viewModel.outputs.pushTokenSuccessfullyGenerated
.observeForUI()
.observeValues { token in
print(" [Push Registration] Push token successfully generated (\(token)) ✨")
}
inputs
和 outputs
两个协议类型的变量带来的好处是区分 ViewModel 数据输入和输出,让代码的意图更清晰。
现在问题来了:如果 inputs
和 outputs
的协议类型带有关联类型,该怎么办?
有关联类型协议的变量
自从阅读了 Kickstarter 的源码,我已经在项目上用上了这种结构模式,其中就遇到了需要把 inputs
和 outputs
定义为带有关联类型协议的变量的情况。
我的情况如下:有很多个页面都是从服务器加载一个数组,然后用 UITableView
显示出来,每个页面都对应一个 ViewModel。写着写着你会发现,这些 ViewModel 都非常类似,除了数组元素的类型不一样,其他都一样,所以我们可以把这些 ViewModels 抽象出一个泛型的 ViewModel,这样就可以一个 ViewModel 用在所有显示数组的界面上。
我首先尝试把 ViewModel 的代码如下:
protocol ListViewModelInputs {
func viewDidLoad()
}
protocol ListViewModelOutputs {
associatedtype ItemType
// 报错:Protocol 'ListViewModelOutputs' can only be used as a generic constraint because it has Self or associated type requirements
var itemsLoaded: Signal<[ItemType], Never> { get }
}
protocol ListViewModelType {
var inputs: ListViewModelInputs { get }
var outputs: ListViewModelOutputs { get }
}
class ListViewModel: ListViewModelInputs, ListViewModelOutputs, ListViewModelType {
init(
loadList: @escaping () -> SignalProducer, ErrorEnvelope>
) {
let loadItems = viewDidLoadProperty.signal
.switchMap { _ in
loadList().materialize()
}
itemsLoaded = loadItems.values().map { $0.models }
}
let viewDidLoadProperty = MutableProperty(())
func viewDidLoad() {
viewDidLoadProperty.value = ()
}
var itemsLoaded: Signal<[ItemType], Never>
var inputs: ListViewModelInputs { return self }
// 报错 'ListViewModelOutputs' can only be used as a generic constraint because it has Self or associated type requirements
var outputs: ListViewModelOutputs { return self }
}
当代码写完后发现,报错了,错误的意思是说 ListViewModelOutputs
只能用作泛型约束,因为它具有 Self 或关联的类型要求。
难道无法定义有关联类型协议的变量了吗?不,还是可以定义的,在 iOS 13 以上,可以把 ListViewModelOutputs
改为:
protocol ListViewModelType {
associatedtype OutputType: ListViewModelOutputs
var inputs: ListViewModelInputs { get }
var outputs: OutputType { get }
}
class ListViewModel: ListViewModelInputs, ListViewModelOutputs, ListViewModelType {
var outputs: some ListViewModelOutputs { return self }
}
ListViewModelType
的 outputs
使用了关联按类型, ListViewModel 的 outputs
使用了 some
关键字,改成这样就不会报错了。
some
是 Swift 5.1 新增的特性,想要具体了解 some
,可以查看之前写的文章 Swift 5.1 新特性
,搜索 模糊的结果类型 (Opaque Result Types)
。
虽然报错的问题解决了,但是 Kickstarter 的这种 ViewModel 结构模式就无法使用了。例如有一个 ViewModel:
let taxViewModel = ListViewModel(loadList: AppEnvironment.current.apiService.loadTaxes)
问题在于 taxViewModel.outputs.itemsLoaded
的类型是 Signal<[(some TestListViewModelOutputs).ItemType], Never>
,而不是我们想要的 Signal<[Tax], Never>
。
所以我最后不得不把相关的 protocol 去掉,直接定义 class:
class ListViewModel {
init(
loadList: @escaping () -> SignalProducer, ErrorEnvelope>
) {
let loadItems = viewDidLoadProperty.signal
.switchMap { _ in
loadList().materialize()
}
itemsLoaded = loadItems.values().map { $0.models }
}
let viewDidLoadProperty = MutableProperty(())
func viewDidLoad() {
viewDidLoadProperty.value = ()
}
var itemsLoaded: Signal<[ItemType], Never>
var inputs: ListViewModel { return self }
var outputs: ListViewModel { return self }
}
这里的 inputs
和 outputs
主要是要为了 ViewModel 的风格保持一致,并不能严格区分输入和输出。
思考
对于上面 taxViewModel
的例子:
let taxViewModel = ListViewModel(loadList: AppEnvironment.current.apiService.loadTaxes)
taxViewModel.outputs.itemsLoaded
的类型是 Signal<[(some TestListViewModelOutputs).ItemType], Never>
,而不是我们想要的 Signal<[Tax], Never>
。
我认为编译器应该把 taxViewModel.outputs.itemsLoaded
推断成 Signal<[Tax], Never>
类型。因为 ListViewModel
已经明确 ItemType
是 Tax
类型,也就意味着 ListViewModelOutputs
协议规定的 var itemsLoaded: Signal<[ItemType], Never>
具体类型是 Signal<[Tax], Never>
,所以 taxViewModel.outputs.itemsLoaded
应该是 Signal<[Tax], Never>
类型。
想及时看到我的新文章的,可以关注我。同时也欢迎加入我管理的Swift开发群:536353151
。