@ObservedObject in iOS Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare an observed object in a SwiftUI view.

iOS Swift

struct ContentView: View {
  @ObservedObject var viewModel = [1]()

  var body: some View {
    Text(viewModel.title)
  }
}

Drag options to blanks, or click blank then click option'

AMyViewModel

BString

CInt

DView

Attempts:

3 left

💡 Hint

Common Mistakes

Using a struct instead of a class for the observed object.

Forgetting to mark the class with ObservableObject protocol.

You use @ObservedObject to watch an instance of a class that conforms to ObservableObject, like MyViewModel.

2fill in blank

medium

Complete the code to update the view when the observed object changes.

iOS Swift

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

struct ContentView: View {
  @ObservedObject var viewModel = MyViewModel()

  var body: some View {
    Button(action: {
      viewModel.count [1] 1
    }) {
      Text("Count: \(viewModel.count)")
    }
  }
}

Drag options to blanks, or click blank then click option'

A-=

B+=

C*=

D/=

Attempts:

3 left

💡 Hint

Common Mistakes

Using = instead of +=, which replaces the value instead of adding.

Using the wrong operator like -= which subtracts.

To increase the count by 1, use the += operator.

3fill in blank

hard

Fix the error in the observed object declaration to properly update the view.

iOS Swift

class Counter: ObservableObject {
  var value = 0
}

struct ContentView: View {
  @ObservedObject var counter = [1]()

  var body: some View {
    Text("Value: \(counter.value)")
  }
}

Drag options to blanks, or click blank then click option'

APublished

BObservableObject

CCounter

DStateObject

Attempts:

3 left

💡 Hint

Common Mistakes

Using the protocol name ObservableObject instead of the class name.

Using @StateObject instead of @ObservedObject in this context.

The observed object must be an instance of the class Counter.

4fill in blank

hard

Fill both blanks to declare a published property and update it correctly.

iOS Swift

class TimerModel: ObservableObject {
  @[1] var seconds = 0

  func tick() {
    seconds [2] 1
  }
}

Drag options to blanks, or click blank then click option'

APublished

B+=

C-=

DState

Attempts:

3 left

💡 Hint

Common Mistakes

Using @State instead of @Published inside ObservableObject.

Using = instead of += which replaces the value.

Use @Published to mark properties that trigger view updates. Use += to add 1 to seconds.

5fill in blank

hard

Fill all three blanks to create an observed object, update a published property, and display it.

iOS Swift

class ScoreModel: ObservableObject {
  @[1] var score = 0

  func increase() {
    score [2] 10
  }
}

struct ScoreView: View {
  @ObservedObject var model = ScoreModel()

  var body: some View {
    VStack {
      Text("Score: \(model.[3])")
      Button("Add 10") {
        model.increase()
      }
    }
  }
}

Drag options to blanks, or click blank then click option'

APublished

B+=

Cscore

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong property name in the Text view.

Forgetting to mark the property with @Published.

Use @Published for the property, += to add 10, and 'score' to display the property.

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