@ObservedObject in iOS Swift

Introduction

@ObservedObject helps your app watch for changes in data from outside your view. When the data changes, the view updates automatically. This keeps your app's screen fresh without you having to refresh it manually.

You want a view to update when data changes in a separate object.

You have a shared data model that multiple views need to watch.

You want to keep your data logic separate from your view code.

You want to react to changes in data that come from network or user input.

You want to build a simple app that updates UI automatically when data changes.

Syntax

iOS Swift

@ObservedObject var model: YourObservableClass

The class you observe must conform to ObservableObject.

Use @Published inside the class to mark properties that trigger updates.

Examples

This example shows a simple counter class and a view that watches it. When count changes, the text updates.

iOS Swift

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

struct ContentView: View {
  @ObservedObject var counter = Counter()

  var body: some View {
    Text("Count: \(counter.count)")
  }
}

This example shows a timer model and a view that updates the seconds display automatically.

iOS Swift

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

struct TimerView: View {
  @ObservedObject var timer = TimerModel()

  var body: some View {
    Text("Seconds: \(timer.seconds)")
  }
}

Sample App

This app shows a number and a button. When you tap the button, the number goes up. The view updates automatically because it watches the Counter object with @ObservedObject.

iOS Swift

import SwiftUI

class Counter: ObservableObject {
  @Published var count = 0

  func increment() {
    count += 1
  }
}

struct ContentView: View {
  @ObservedObject var counter = Counter()

  var body: some View {
    VStack(spacing: 20) {
      Text("Count: \(counter.count)")
        .font(.largeTitle)
      Button("Increment") {
        counter.increment()
      }
      .padding()
      .background(Color.blue)
      .foregroundColor(.white)
      .cornerRadius(8)
    }
    .padding()
  }
}

@main
struct MyApp: App {
  var body: some Scene {
    WindowGroup {
      ContentView()
    }
  }
}

Important Notes

Only use @ObservedObject for objects created outside the view or passed in. For objects created inside the view, use @StateObject.

Make sure your observable class uses @Published for properties you want to trigger view updates.

Views using @ObservedObject will redraw when the observed object changes.

Summary

@ObservedObject watches an external data object for changes.

When the data changes, the view updates automatically.

Use it to keep your UI in sync with your data model.

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