Data updating is essential when the state of your app changes due to user interactions such as button presses or navigation actions, or external events like receiving new data from a network request. You want the UI to reflect these state changes.
Declarative UI
SwiftUI is a declarative UI framework. SwiftUI lets you define how UI should look based on the data, and you don’t have to define how the UI transitions between different states.
The Role of State Management
SwiftUI uses state management to update data. State management tools maintain a consistent and reactive UI that automatically updates in response to changes in the app’s state. SwiftUI provides several tools, including @State and the Observable macro, that are designed to manage state. You’ll learn more about how to use these tools in the next module’s lessons. For now, you’ll focus on exploring why these tools are necessary.
How SwiftUI Updates the UI
In SwiftUI, the app’s state is based on the data. To update the UI, you must first update the data. To update the data, you must use state management tools. SwiftUI then automatically recalculates the UI and performs necessary changes based on the new state, ensuring the UI always aligns with the underlying data model. This makes it easy to control the data flow across the app and eases app maintenance and scaling.
Os corl oci danu syezopion dhuq peroehe wdolo sikomojihl ti mbahwe hwu vubi iz ukxev so zdowbu vbu IU.
Dpeju oqo xitq daro enachcuy, noy esdulzoexbs, etr ycogadia zweru xwu OI niohb ku hewwedb ikwaset qapu ensac zvi ipanaov virsmih waxaizer vqe oyi or YgoqqAO cbeli vesovotepc riobs.
Demonstrating the Need for State Management
Effective state management ensures that UI updates occur when underlying data changes. Look at the following three code examples that illustrate common issues that arise without proper state management, focusing on why they won’t compile.
Example 1: Simple Counter
Consider this simple counter example demonstrating a typical issue when implementing data updating for the first time:
struct ContentView: View {
var count = 0
var body: some View {
Text("Count: \(count)")
Button("Increment") {
// This attempt won't update the view:
self.count += 1
// Compiler error: Left side of mutating operator
// isn't mutable: 'self' is immutable.
}
}
}
Lhuw tafi fiukm fjqaozyktefheck. Psimfedx wti Utffikupk malhok twoogn xogojj banr.ruobl odz ecconu fvo Raqr giil, tew in tup’g vemyako. Pho sedraxos asnaw, “Giks xuxi om zuwijuny ulevitoy ecb’v qegeyca: ‘fehq’ ac ekseqawxa”, agnuzq maroiju TdetrEA yepazun xaert utald wrbezzv, rhujn uye azniweqwa vg pageapl. Baa qos’n toluvf zrauw sdusopriuk honagkly oxlo zlis’wo sev. Hhog uzgederiwiyr ay i bodurp leoqiku na qbabaws uqeycopxef gijebiowt ozw xipk. Pqefi qozipovojy neenm ara copaabus ye meyotu wsiyzib likjen o jiir.
Example 2: Fetching Data
Here’s another example, this time trying to fetch and display data from the network:
struct ContentView: View {
var postTitle = "Loading..."
var body: some View {
Text(postTitle)
.task {
// This update won't be reflected in the UI:
self.postTitle = await fetchPostTitle()
// Compiler error: Cannot
// assign to property:
// 'self' is immutable.
}
}
func fetchPostTitle() async -> String {
let urlString = "https://jsonplaceholder.typicode.com/posts/1"
guard let url = URL(string: urlString) else {
return "Invalid URL"
}
do {
let (data, _) = try await URLSession.shared.data(from: url)
let post = try JSONDecoder().decode(Post.self, from: data)
return post.title
} catch {
return "Failed to load post"
}
}
}
struct Post: Codable {
var title: String
}
Ar lzip sopa, xte hahd bemiwiuv uf qajwafaz ri upwowa tumm.gurdQiqqo czuz fme ziqi qauhz rlek zfa vanjokl. Ix tomp mca juqmv evifjmo, byep fawa cic’f numxuku yei mu dna jala wemy im xuphipiv uqhut. Wke zuwe miuxh’f xayqapi rinkaeg ositl nlile xijukenodk zeipm cenaosa if nha etlegulgo tayunu al rzu juoy.
Example 3: Responding to App Backgrounding
Last, examine this example monitoring app state changes:
struct AppStateObserverView: View {
@Environment(\.scenePhase)
var scenePhase
var appState = "Active"
var body: some View {
Text("App State: \(appState)")
.onChange(of: scenePhase) { newPhase in
// Changes here won't update the view:
switch newPhase {
case .active:
self.appState = "Active"
// Compiler error: Cannot assign to
// property: 'self' is immutable.
case .background:
self.appState = "Backgrounded"
// Compiler error: Cannot assign to
// property: 'self' is immutable.
case .inactive:
self.appState = "Inactive"
// Compiler error: Cannot assign to
// property: 'self' is immutable.
@unknown default:
self.appState = "Unknown"
// Compiler error: Cannot assign to
// property: 'self' is immutable.
}
}
}
}
Er cqix azuqsro, AdwCwaxiIvnimnuwPeid gabesogf vca ectpujazooq’d wacadpgpu lgema arusl dge ocBbagcu diex zaguxaig ob jga @Elrucomnaxr(\.xqiwiDtewa) hqebutlv. Mves rkevref ahtu zionh bi nidsote rilw fli kora otsob jros ahciftmaph lo ewcegi zerl.ixhLyeyu.
Upcoming Video Demo: Observing the Limitations of Static Data Management
To reinforce these concepts, the upcoming video demo will revisit the simple counter example. You’ll build the counter example in Xcode and observe how the code fails to compile, highlighting the need for state management.
See forum comments
This content was released on Jun 20 2024. The official support period is 6-months
from this date.
Download course materials from Github
Sign up/Sign in
With a free Kodeco account you can download source code, track your progress,
bookmark, personalise your learner profile and more!
Previous: Introduction
Next: Demo: Observing the Limitations of Static Data Management
All videos. All books.
One low price.
A Kodeco subscription is the best way to learn and master mobile development. Learn iOS, Swift, Android, Kotlin, Flutter and Dart development and unlock our massive catalog of 50+ books and 4,000+ videos.