@ObservedObject in iOS Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

How does @ObservedObject update the UI?

Consider a SwiftUI view using an @ObservedObject to watch a data model. What happens when a published property in the observed object changes?

iOS Swift

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

struct ContentView: View {
  @ObservedObject var counter = Counter()
  var body: some View {
    Text("Count: \(counter.count)")
  }
}

A The app crashes because @ObservedObject cannot be used with classes.

B The Text view does not update unless the view is recreated manually.

C The Text view updates automatically to show the new count value.

D The Text view updates only if the count property is marked with @State.

💡 Hint

Think about how SwiftUI listens to changes in ObservableObject classes.

When a property marked with @Published inside an ObservableObject changes, any SwiftUI view observing it with @ObservedObject automatically refreshes its body to reflect the new data.

❓ lifecycle

intermediate

When is an @ObservedObject recreated in SwiftUI?

Given a SwiftUI view with an @ObservedObject property initialized inside the view struct, when does the observed object get recreated?

iOS Swift

class TimerModel: ObservableObject {
  @Published var time = 0
}

struct TimerView: View {
  @ObservedObject var timer = TimerModel()
  var body: some View {
    Text("Time: \(timer.time)")
  }
}

A The TimerModel instance is created once and reused across redraws.

B Every time the view redraws, a new TimerModel instance is created.

C The TimerModel instance is never created because @ObservedObject requires external injection.

D The TimerModel instance is created only when the app launches.

💡 Hint

Think about how SwiftUI structs are recreated and what happens to properties initialized inside them.

When you initialize an @ObservedObject inside a view struct, it gets recreated every time the view redraws, which can cause unexpected behavior. Usually, @ObservedObject expects the object to be created outside and passed in.

🔧 Debug

advanced

Why does the UI not update when using @ObservedObject?

You have this code but the UI does not update when the data changes. What is the most likely cause?

iOS Swift

class DataModel: ObservableObject {
  var value = 0
}

struct ContentView: View {
  @ObservedObject var model = DataModel()
  var body: some View {
    Text("Value: \(model.value)")
  }
}

A The value property is not marked with @Published, so changes are not announced.

B The DataModel class must inherit from NSObject for @ObservedObject to work.

C The Text view must be inside a VStack to update properly.

D The @ObservedObject property wrapper must be replaced with @State for updates.

💡 Hint

Check how SwiftUI knows when to update views based on ObservableObject changes.

Only properties marked with @Published inside an ObservableObject send change notifications. Without @Published, SwiftUI does not know when the property changes and won't update the UI.

❓ navigation

advanced

Passing @ObservedObject between views

You want to share a data model between two SwiftUI views so both update when the model changes. Which approach correctly shares the @ObservedObject?

iOS Swift

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

struct ParentView: View {
  @StateObject var settings = UserSettings()
  var body: some View {
    ChildView(settings: settings)
  }
}

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

A ParentView creates the UserSettings with @StateObject and passes it to ChildView as @ObservedObject.

B UserSettings should be passed as a plain variable without property wrappers.

C ChildView should use @StateObject to create UserSettings instead of @ObservedObject.

D Both ParentView and ChildView create their own UserSettings with @ObservedObject.

💡 Hint

Think about which view owns the data and which views observe it.

The parent view owns the data model using @StateObject. It passes the model down to child views as @ObservedObject so they observe changes without owning the data.

🧠 Conceptual

expert

Difference between @ObservedObject and @StateObject

Which statement best describes the difference between @ObservedObject and @StateObject in SwiftUI?

A @StateObject is used only for structs; @ObservedObject is used only for classes.

B @ObservedObject creates and owns the ObservableObject instance; @StateObject only observes an existing instance.

C Both @ObservedObject and @StateObject create new instances every time the view redraws.

D @StateObject creates and owns the ObservableObject instance; @ObservedObject only observes an existing instance.

💡 Hint

Consider which property wrapper manages the lifecycle of the object.

@StateObject is used to create and keep the ObservableObject alive for the life of the view. @ObservedObject is used to observe an object created elsewhere.