Why @ObservedObject in iOS Swift? - Purpose & Use Cases

The Big Idea

What if your app could update itself instantly without you writing extra update code?

The Scenario

Imagine you build an app where you manually check if data changed in one screen to update another screen. You have to write extra code to watch for changes everywhere.

The Problem

This manual checking is slow and easy to forget. If you miss updating one place, the app shows old data. It feels like constantly babysitting your app to keep it in sync.

The Solution

@ObservedObject lets your app watch data automatically. When data changes, the UI updates by itself without extra code. It keeps your app fresh and saves you from manual updates.

Before vs After

✗ Before

class DataModel {
  var value = 0
  // Need to notify manually
}
// Update UI manually when value changes

✓ After

class DataModel: ObservableObject {
  @Published var value = 0
}
struct ContentView: View {
  @ObservedObject var model: DataModel
  // UI updates automatically
}

What It Enables

You can build apps that react instantly to data changes, making your UI always up-to-date without extra effort.

Real Life Example

In a shopping app, when the cart items change, the total price updates on screen automatically using @ObservedObject, so users see the latest total right away.

Key Takeaways

Manual data syncing is slow and error-prone.

@ObservedObject automates UI updates when data changes.

This makes your app more reliable and easier to build.

Practice

1. What is the main purpose of using @ObservedObject in a SwiftUI view?

easy

A. To watch an external data object and update the view when it changes

B. To create a new data object inside the view

C. To store a constant value that never changes

D. To handle user input events like taps and swipes

Solution

1. Step 1: Understand the role of @ObservedObject

   @ObservedObject is used to watch an external data object for changes.

2. Step 2: Connect data changes to UI updates

   When the observed object changes, the SwiftUI view automatically updates to reflect those changes.

3. Final Answer:

   To watch an external data object and update the view when it changes -> Option A

4. Quick Check:

   @ObservedObject = watch external data [OK]

Hint: Remember: @ObservedObject watches data outside the view [OK]

Common Mistakes:

• Confusing @ObservedObject with @State which owns data inside the view
• Thinking @ObservedObject creates new data instead of observing
• Using @ObservedObject for constant values

2. Which of the following is the correct way to declare an observed object in a SwiftUI view?

easy

A. @ObservedObject var model: MyModel

B. @ObservedObject var model: MyModel = MyModel()

C. @ObservedObject model = MyModel()

D. @ObservedObject var model: MyModel?

Solution

1. Step 1: Understand @ObservedObject declaration

   @ObservedObject properties are typically declared without initialization in the view, expecting the instance to be injected.

2. Step 2: Check syntax correctness

   @ObservedObject var model: MyModel is the correct declaration; initializing it inside the view is not recommended.

3. Final Answer:

   @ObservedObject var model: MyModel -> Option A

4. Quick Check:

   Declare @ObservedObject without initialization for injection [OK]

Hint: Declare @ObservedObject properties without initializing inside the view [OK]

Common Mistakes:

• Initializing @ObservedObject inside the view
• Omitting the var keyword
• Using optional type without proper handling

3. Given the code below, what will be the output when the button is tapped?

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

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

medium

A. The app crashes due to missing @State

B. The text never updates and stays at 0

C. The text updates to show the incremented count each tap

D. The button does not respond to taps

Solution

1. Step 1: Understand @Published and @ObservedObject interaction

   The Counter class publishes changes to its count property.

2. Step 2: Observe how the view updates

   The ContentView observes the counter object, so when count changes, the Text updates automatically.

3. Final Answer:

   The text updates to show the incremented count each tap -> Option C

4. Quick Check:

   @Published + @ObservedObject = UI updates [OK]

Hint: @Published properties trigger view updates via @ObservedObject [OK]

Common Mistakes:

• Thinking @ObservedObject alone updates UI without @Published
• Confusing @State with @ObservedObject
• Assuming UI updates require manual refresh

4. Identify the error in this SwiftUI view using @ObservedObject:

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

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

medium

A. The TimerModel class is missing ObservableObject conformance

B. The @ObservedObject property is not initialized

C. The @Published property should be private

D. The Text view syntax is incorrect

Solution

1. Step 1: Check class conformance

   TimerModel correctly conforms to ObservableObject.

2. Step 2: Check @ObservedObject initialization

   The timer property is declared but not initialized, causing a compile error.

3. Final Answer:

   The @ObservedObject property is not initialized -> Option B

4. Quick Check:

   @ObservedObject must be initialized or injected [OK]

Hint: Always initialize or inject @ObservedObject properties [OK]

Common Mistakes:

• Forgetting to initialize @ObservedObject
• Assuming @Published must be private
• Misreading Text string interpolation

5. You have a parent view that creates a Settings object and passes it to two child views. Which is the best way to share this data so both children update when settings change?

hard

A. Use @EnvironmentObject in children without passing from parent

B. Create separate @ObservedObject instances in each child view

C. Use @State in the parent and @Binding in children for the settings

D. Declare @ObservedObject in both child views and pass the same Settings instance from the parent

Solution

1. Step 1: Understand data sharing with @ObservedObject

   Passing the same instance to children with @ObservedObject keeps them in sync.

2. Step 2: Evaluate other options

   Creating separate instances duplicates data; @State/@Binding is for simple values; @EnvironmentObject requires environment setup.

3. Final Answer:

   Declare @ObservedObject in both child views and pass the same Settings instance from the parent -> Option D

4. Quick Check:

   Share one @ObservedObject instance for synced updates [OK]

Hint: Pass one @ObservedObject instance to children for shared updates [OK]

Common Mistakes:

• Creating multiple instances causing unsynced data
• Confusing @Binding with @ObservedObject for complex objects
• Using @EnvironmentObject without setup