@EnvironmentObject for shared state in iOS Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What will be displayed when the button is tapped?

Consider this SwiftUI code where a shared counter is updated using @EnvironmentObject. What text will appear after tapping the button once?

iOS Swift

class Counter: ObservableObject {
  @Published var count = 0
}

struct ContentView: View {
  @EnvironmentObject var counter: Counter
  var body: some View {
    VStack {
      Text("Count: \(counter.count)")
      Button("Increment") {
        counter.count += 1
      }
    }
  }
}

A Count: 0

B Count: 2

C App crashes due to missing environment object

D Count: 1

💡 Hint

Remember that tapping the button increases the count by 1 and the view updates automatically.

The @EnvironmentObject 'counter' is shared and observed. When the button increments 'count', the Text updates to show the new value, which is 1 after one tap.

❓ lifecycle

intermediate

What happens if @EnvironmentObject is not injected?

Given a SwiftUI view that uses @EnvironmentObject but the environment object is not provided in the view hierarchy, what will happen when the app runs?

iOS Swift

class UserSettings: ObservableObject {
  @Published var username = "Guest"
}

struct ProfileView: View {
  @EnvironmentObject var settings: UserSettings
  var body: some View {
    Text("User: \(settings.username)")
  }
}

A The app crashes at runtime with a fatal error

B The Text shows 'User: Guest' by default

C The Text shows empty string

D The app compiles but the view does not update

💡 Hint

Think about what happens if the environment object is missing when the view tries to access it.

If the environment object is not injected, SwiftUI triggers a runtime fatal error because the view expects the object to be present.

🧠 Conceptual

advanced

How does @EnvironmentObject differ from @ObservedObject?

Which statement correctly describes the difference between @EnvironmentObject and @ObservedObject in SwiftUI?

A @EnvironmentObject is injected automatically from the environment, while @ObservedObject requires manual passing of the object.

B @ObservedObject is used only for local state, @EnvironmentObject only for global constants.

C @EnvironmentObject cannot trigger view updates, @ObservedObject can.

D @ObservedObject shares data across unrelated views automatically.

💡 Hint

Consider how each property wrapper receives its data and how it is passed to views.

@EnvironmentObject expects the object to be provided in the environment and is injected automatically. @ObservedObject requires the object to be passed explicitly to the view.

🔧 Debug

advanced

Why does this view not update when the shared state changes?

Given this code, why does the Text not update when the button is tapped?

iOS Swift

class Score: ObservableObject {
  @Published var points = 0
}

struct ScoreView: View {
  var score = Score()
  var body: some View {
    VStack {
      Text("Points: \(score.points)")
      Button("Add Point") {
        score.points += 1
      }
    }
  }
}

A Because the Button action is not called

B Because @Published does not work with Int properties

C Because 'score' is not marked with @StateObject or @ObservedObject, so changes don't trigger view updates

D Because the Text view is outside the VStack

💡 Hint

Think about how SwiftUI detects changes in observable objects to update views.

The 'score' property is a plain variable, not observed by SwiftUI. Without @StateObject or @ObservedObject, changes to 'points' do not cause view updates.

❓ navigation

expert

How to share @EnvironmentObject across multiple views in a navigation stack?

You want to share a UserSettings object using @EnvironmentObject across several views pushed in a NavigationStack. Which code snippet correctly injects the environment object so all views can access it?

A

NavigationStack {
  ContentView().environmentObject(UserSettings())
}

B

NavigationStack {
  ContentView()
}.environmentObject(UserSettings())

C

ContentView().environmentObject(UserSettings())
NavigationStack { ContentView() }

D

NavigationStack {
  ContentView()
}
UserSettings()

💡 Hint

The environment object must be injected at the root of the view hierarchy that contains the navigation stack.

Injecting the environment object on the NavigationStack ensures all views inside it receive the shared object automatically.