I wrote an app known as SwiftUI View Lifecycle. The app means that you can observe how totally different SwiftUI constructs and containers have an effect on a view’s lifecycle, together with the lifetime of its state and when onAppear
will get known as. The code for the app is on GitHub. It may be constructed for iOS and macOS.
Once we write SwiftUI code, we assemble a view tree that consists of nested view values. Situations of the view tree are ephemeral: SwiftUI always destroys and recreates (components of) the view tree because it processes state modifications.
The view tree serves as a blueprint from which SwiftUI creates a second tree, which represents the precise view “objects” which might be “on display screen” at any given time (the “objects” may very well be precise UIView
or NSView
objects, but in addition different representations; the precise that means of “on display screen” can range relying on context). Chris Eidhof likes to name this second tree the render tree (the hyperlink factors to a 3 minute video the place Chris demonstrates this duality, extremely really useful).
The render tree persists throughout state modifications and is utilized by SwiftUI to ascertain view identification. When a state change causes a change in a view’s worth, SwiftUI will discover the corresponding view object within the render tree and replace it in place, somewhat than recreating a brand new view object from scratch. That is after all key to creating SwiftUI environment friendly, however the render tree has one other necessary perform: it controls the lifetimes of views and their state.
We are able to outline a view’s lifetime because the timespan it exists within the render tree. The lifetime begins with the insertion into the render tree and ends with the removing. Importantly, the lifetime extends to view state outlined with @State
and @StateObject
: when a view will get faraway from the render tree, its state is misplaced; when the view will get inserted once more later, the state will likely be recreated with its preliminary worth.
The SwiftUI View Lifecycle app tracks three lifecycle occasions for a view and shows them as timestamps:
- @State = when the view’s state was created (equal to the beginning of the view’s lifetime)
- onAppear = when
onAppear
was final known as - onDisappear = when
onDisappear
was final known as
The app means that you can observe these occasions in several contexts. As you click on your manner via the examples, you’ll discover that the timing of those occasions modifications relying on the context a view is embedded in. For instance:
- An
if
/else
assertion creates and destroys its little one views each time the situation modifications; state just isn’t preserved. - A
ScrollView
eagerly inserts all of its kids into the render tree, no matter whether or not they’re contained in the viewport or not. All kids seem straight away and by no means disappear. - A
Checklist
with dynamic content material (utilizingForEach
) lazily inserts solely the kid views which might be presently seen. However as soon as a toddler view’s lifetime has began, the checklist will hold its state alive even when it will get scrolled offscreen once more.onAppear
andonDisappear
get known as repeatedly as views are scrolled into and out of the viewport. - A
NavigationStack
callsonAppear
andonDisappear
as views are pushed and popped. State for father or mother ranges within the stack is preserved when a toddler view is pushed. - A
TabView
begins the lifetime of all little one views straight away, even the non-visible tabs.onAppear
andonDisappear
get known as repeatedly because the consumer switches tabs, however the tab view retains the state alive for all tabs.
Listed below are just a few classes to remove from this:
- Totally different container views might have totally different efficiency and reminiscence utilization behaviors, relying on how lengthy they hold little one views alive.
onAppear
isn’t essentially known as when the state is created. It may well occur later (however by no means earlier).onAppear
might be known as a number of instances in some container views. In case you want a aspect impact to occur precisely as soon as in a view’s lifetime, take into account writing your self anonFirstAppear
helper, as proven by Ian Eager and Jordan Morgan in Operating Code Solely As soon as in SwiftUI (2022-11-01).
I’m positive you’ll discover extra attention-grabbing tidbits if you play with the app. Suggestions is welcome!