1.4 SwiftUI 视图管理机制

目录

视图的身份标识(Identity)

在 UIKit/AppKit 的世界,UIView/NSView 实例是引用类型(class),程序通过指针来引用和区分对象。要实现界面的更新,我们首先需要找到对应的视图,然后下达相应的指令,比如改变视图的位置或者颜色,然后界面才会随之更新,这是典型的命令式编程。

而 SwiftUI 是响应式编程框架,我们只需声明 UI 的布局并将其和状态(或者叫数据)绑定,然后只需要维护状态即可。状态是响应式编程的核心概念,它的改变会驱动视图的更新。在 SwiftUI 中,视图都是 View 协议的具体实现,状态的流转会触发 body 的重新计算,反映的结果就是视图的重绘。状态的变化会实时反馈在 view 上,view 其实是状态的一部分。

但 SwiftUI 中的 View 实例是值类型(struct),之前的引用机制已经不再适用。那么它是如何找到和区分视图并重新渲染界面的呢?答案是 Identity(以下简称 id)。

SwiftUI 具有多个场景(scene),它们组成了程序的界面。而每个 scene 独立管理自身的生命周期和视图层级,这些视图的结构类似于一个树形结构,而 scene 就是根节点。这颗树上的任何一个 view 都有一个表明身份的 id,便于 SwiftUI 查找、比对和更新视图。id 有两种表现形式:显式 id 和结构化 id(也可以称作隐式 id)。

关于 Scene 的详细介绍,详见《SwiftUI 中的场景》。

显式 id

下面是一个使用 List 实现的天气列表:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
struct Weather {
  var name: String
  var icon: String
  
  static var mock: [Self] {
    [
      .init(name: "Sun", icon: "sun.max.fill"),
      .init(name: "Rain", icon: "cloud.rain.fill"),
      .init(name: "Snow", icon: "snowflake"),
    ]
  }
}

struct WeatherView: View {
  
  @State private var weathers = Weather.mock
  
  var body: some View {
    List(weathers, id: \.name) {
      Label($0.name, systemImage: $0.icon)
    }
  }
}

List 初始化时的 id 参数是显式分配的,它通过 keyPath 的形式获取到数据源 weathers 中的每条数据的 name 属性,将其与每个 Label 实例绑定起来。如此一来,SwiftUI 就可以很方便地根据 id 去渲染和更新相应的 label。

不过,上面的代码有潜在问题。比如,weathers 中存在多条 name 相同的数据时,如果只想对其中一条数据操作,那么根据 name 就无法区分了。所以,为每条数据分配一个唯一的标识符是较为明智的做法,很容易想到使用 Identifiable 协议来解决这个问题。

1
2
3
4
- struct Weather {
+ struct Weather: Identifiable {
+   let id = UUID()
}

如上,使 Weather 实现 Identifiable 协议后。将 List 初始化方法中的 \.name 改为 \.id ,就能解决上述潜在问题。

SwiftUI 中的 List 支持多个初始化方法,如果数据集合中的元素已经实现了 Identifiable 协议,则无需显示指定 id,SwiftUI 会找到对应的 id 自动分配。也就是说下面的代码也是合理的:

1
2
3
List(weathers) {
  Label($0.name, systemImage: $0.icon)
}

id 有助于 SwiftUI 更好地构建和管理视图,当我们需要操作指定的视图时,也需要借助 id 来实现。比如 ScrollView 根据 id 跳转到相应的视图:

> 查看示例

结构化 id

上文说到使用 id 告知 SwiftUI 如何区分 List 中的条目,但 List 实例本身似乎并没有 id,SwiftUI 如何在视图层级中找到它呢?实际上,SwiftUI 会为其隐式分配 id,又称结构化 id。

多数情况下,SwiftUI 会使用结构化 id 为视图隐式表明身份。然而,SwiftUI 并非全知全能,它有时也需要借助我们为视图显式指定 id:

  • 结构化 id 无法明确区分视图时,比如 List 的数据源如有重复时,可能会导致无法预期的结果。因此对于动态加载的视图(List、ForEach 等),无论数据源是否有实现 Identifiable 协议,推荐显式指定 id,使之成为习惯。
  • 需要手动调用指定视图时,比如上面的 ScrollView。

视图的生命周期

SwiftUI 是一个由数据驱动的声明式框架,当数据变化时,与之绑定的视图会发生重绘。这里的重绘又分为两种情况:

  1. 原视图销毁,重新创建新视图。
  2. 原视图保留,只更新外观样式。

> 查看示例

为了演示二者的区别,示例的源码中为 Text 实例显式指定了一个 id,当没有打开改变 id 的开关时,动画非常流畅。而打开开关时,动画非常生硬,过渡效果不尽人意。

这是因为,SwiftUI 中视图的身份标识是与 view 唯一对应的。改变 text 的 id 后,SwiftUI 会认定原有的 text 并非它要查找的视图,它会销毁原来的 text,重新创建新的 text 替代原来的 text 并将其更新至视图层级。由于前后两个 text 并非同一个对象,SwiftUI 就无法找到一个作动画的锚点进行平滑的过渡,所以视觉上呈现的就只是两个 text 的渐变而已。而没有改变 text 的 id 时,该实例一直存活于视图层级中,它的生命延续着,SwiftUI 根据 id 找到该视图,然后对该视图的属性做插值动画,视觉上就是平滑的过渡效果。

前文提到,SwiftUI 中的视图层级类似于一个树形结构。当某个视图所依附的节点被销毁时,它的生命周期自然也就结束了。视图的销毁会导致它的身份标识不复存在,身份标识的改变也会导致视图的销毁。因此可以认为,view 的生命周期几乎等同于其身份标识(id)。

视图的更新和优化

程序运行时,视图的频繁更新是非常常见的。虽然 SwiftUI 中的 view 是值类型的结构体,它们非常轻量、安全,但我们应该尽可能地为 view 提供稳定的 id,这有助于提高程序性能。因为稳定的 id 有助于维持视图的生命周期,这避免了视图的频繁销毁和重建,也为流畅的动画提供了基础。另一方面,SwiftUI 在更新视图树时会进行快照比对,如果某个视图的身份标识没有变化,而且数据也没有变化,它就不必为此进行无谓的计算了。

条件渲染的隐患

SwiftUI 支持使用 if 或者 if/else 进行条件渲染,比如下面的代码表示的是如果是 vip,则展示用户的 vip 标识:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
@State private var isVip1 = false

HStack {
  if isVip1 {
    HStack {
      Text("Bruce")
      Text(Image(systemName: "crown.fill"))
    }
    .padding(10)
    .background(Color.blue)
    .cornerRadius(10)
  } else {
    Text("Bruce")
  }
  
  Spacer()
  
  Toggle("", isOn: $isVip1.animation(.easeInOut(duration: 0.5)))
}

这里为 isVip1 添加了绑定值动画,当开关打开时,与 isVip1 属性相关的视图会有动画效果。然而,动画过渡地不够平滑。原因和上文类似,条件渲染会造成视图的销毁和重建。不过条件渲染有点特别,编译器会将 if/else 语句转化成 ConditionalConent<TrueView, FalseView> 这样的实例,虽然从外表上看,视图类型(ConditionalConent)是一致的,但渲染条件的变化会导致其内部的视图身份发生改变,故而动画变得生硬了。至于 SwiftUI 为何会设计 ConditionalConent 来进行条件渲染,有一种说法是这样的:为了更高效的进行差异对比。对此,笔者并未进行更深入的研究,如果你有更高明的解释,欢迎探讨。

即然知道了问题所在,那么解决方法就有了:避免使用条件渲染,维持视图的稳定 id 和生命周期。代码比较简单,请查看示例中的源码。

> 查看示例

避免使用 AnyView

如果遇到需要返回不同类型的 View 时,AnyView 也许是一种解决方法。它能够擦除视图的类型信息,但它会使代码变得难以读写,更糟糕的是带来了性能损耗,因此应该尽量避免使用它。

这里先不展开介绍 AnyView,先记住尽量避免使用它。遇到需要返回不同类型的视图时,笔者提供三个解决思路供参考:

  • 使用 @ViewBuilder 构建视图。

  • 使用 Group 包装视图保持类型一致。

  • 借助泛型(View)来传参

合理使用 EquatableView

上文说到,如果视图的身份和数据都没有变化,那么 SwiftUI 不会对它进行无谓的计算和渲染。不过这里面有个隐含条件,我们先来看一个示例。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
struct CityNameView: View {
  
  let name: String
  
  var body: some View {
    printLog("refresh")
    return Text(name).font(.title)
  }
}

struct WeatherView: View, Equatable {
  
  let weather: Weather
  
  var body: some View {
    printLog("refresh")
    return Label(
      // 温度数字 格式化
      weather.temperature.celsiusFormat,
      systemImage: weather.icon
    )
  }
}

为观察 SwiftUI 是否对视图进行了重绘,这里定义的两个视图在计算属性 body 内使用 print 输出。视图重绘时会重新计算 body,控制台输出 “refresh” ,反之没有任何输出。

然后根据这两个视图构建一个新的视图(这里只贴出关键代码,示例完整代码可查看源码):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
@State private var cityName = "Shenzhen"
@State private var weather = Weather.mock.first!

VStack(spacing: 10) {
  CityNameView(name: cityName)
  WeatherView(weather: weather).equatable()
  
  Button("刷新视图") {
    cityName = "Shenzhen"
    weather = Weather.mock.first!
  }
  .buttonStyle(.borderless)
}

按钮点击时,其实什么也没做,只是把同样的值重新赋值给 cityName 和 weather。然而,神奇的事情发生了:CityNameView 不会重绘,而 WeatherView 会一直重绘。这就是前文提到的隐含条件:数据需要实现 Equatable 协议。

这里的 cityName 是 String 类型,本身就实现了 Equatable 协议。而 Weather 并没有实现 Equatable 协议,所以 weather 发生赋值行为时,虽然视图的身份稳定而且前后数据看上去一致,但 SwiftUI 并不知道如何进行数据的比对。

顺着这个思路,我们为 Weather 实现 Equatable 协议:

1
2
3
4
5
6
extension Weather: Equatable {
  
  static func == (lhs: Self, rhs: Self) -> Bool {
    lhs.name == rhs.name && lhs.temperature == rhs.temperature
  }
}

然后,重新运行程序,发现 WeatherView 不会频繁刷新了。

虽然目前实现了想要的效果,但是直接去更改 Weather 的行为会影响到所有调用者,这非常不合理。假设我们只希望 WeatherView 数据发生变化时刷新视图,而其它使用 Weather 作为数据的视图不受影响。该如何实现呢?答案是:EquatableView。

修改的代码如下:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
- struct WeatherView: View {
+ struct WeatherView: View, Equatable {
+   static func == (lhs: Self, rhs: Self) -> Bool {
+     lhs.weather.name == rhs.weather.name &&
+     lhs.weather.temperature == rhs.weather.temperature
+   }

- WeatherView(weather: weather)
+ WeatherView(weather: weather).equatable()
+ // 上面是的写法等同于:
+ // EquatableView(content: WeatherView(weather: weather))

- weather = Weather.mock.first!
+ weather = Weather.mock.randomElement()!

- extension Weather: Equatable {
-
-   static func == (lhs: Self, rhs: Self) -> Bool {
-     lhs.name == rhs.name && lhs.temperature == rhs.temperature
-   }
- }

这次我们让 WeatherView 实现 Equatable 协议,然后为 weatherView 添加修饰器方法 .equatable() 即可。经笔者测试,即使没有调用 .equatable() ,也能实现同样的效果。不过还是建议显式调用,有利于提高程序的可读性。

合理地使用 EquatableView 非常适合某些局部视图不需要频繁刷新的场景,这也有利于提高程序性能。鉴于这个刷新机制是由我们自己根据 Equatable 协议实现的,所以要当心数据发生变化而视图不刷新的问题。


本文参考: