ObservableObject protocol in iOS Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to make the class notify views about changes.

iOS Swift

class UserSettings: [1] {
  @Published var score = 0
}

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

AObservableObject

BView

CState

DApp

Attempts:

3 left

💡 Hint

Common Mistakes

Using View or State instead of ObservableObject.

Forgetting to conform to any protocol.

The class must conform to ObservableObject to notify views when data changes.

2fill in blank

medium

Complete the code to mark a property that triggers view updates.

iOS Swift

class Settings: ObservableObject {
  [1] var isDarkMode = false
}

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

A@State

B@EnvironmentObject

C@ObservedObject

D@Published

Attempts:

3 left

💡 Hint

Common Mistakes

Using @State inside ObservableObject class.

Using @ObservedObject or @EnvironmentObject incorrectly.

@Published marks properties that send change notifications to views.

3fill in blank

hard

Fix the error in the view to observe the object correctly.

iOS Swift

struct ContentView: View {
  [1] var settings = Settings()

  var body: some View {
    Text(settings.isDarkMode ? "Dark" : "Light")
  }
}

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

A@EnvironmentObject

B@Published

C@StateObject

D@ObservedObject

Attempts:

3 left

💡 Hint

Common Mistakes

Using @ObservedObject when the view creates the object.

Using @Published in a view property.

@StateObject creates and owns the ObservableObject in the view lifecycle.

4fill in blank

hard

Fill both blanks to observe an existing object passed from parent view.

iOS Swift

struct DetailView: View {
  [1] var settings: Settings

  var body: some View {
    Toggle("Dark Mode", isOn: $settings.[2])
  }
}

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

A@ObservedObject

BisDarkMode

C@StateObject

Dscore

Attempts:

3 left

💡 Hint

Common Mistakes

Using @StateObject for passed-in objects.

Binding to a property not marked @Published.

Use @ObservedObject to observe an object passed in, and bind to its @Published property.

5fill in blank

hard

Fill all three blanks to create and observe an object in a parent view and pass it to a child view.

iOS Swift

struct ParentView: View {
  [1] var settings = Settings()

  var body: some View {
    ChildView([2]: settings)
  }
}

struct ChildView: View {
  [3] var settings: Settings

  var body: some View {
    Text(settings.isDarkMode ? "Dark" : "Light")
  }
}

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

A@StateObject

Bsettings

C@ObservedObject

D@Published

Attempts:

3 left

💡 Hint

Common Mistakes

Using @ObservedObject in parent view for object creation.

Not passing the object with the correct parameter name.

Using @Published in views.

Parent uses @StateObject to create the object, passes it as 'settings', child uses @ObservedObject to observe it.

Practice

1. What is the main purpose of the ObservableObject protocol in SwiftUI?

easy

A. To handle user input events

B. To create a new view in SwiftUI

C. To allow a class to notify views when its data changes

D. To manage app navigation between screens

Solution

1. Step 1: Understand ObservableObject role

   The ObservableObject protocol is designed to let a class broadcast changes to its data.

2. Step 2: Connect data changes to UI updates

   When data changes, views observing the object update automatically, keeping UI in sync.

3. Final Answer:

   To allow a class to notify views when its data changes -> Option C

4. Quick Check:

   ObservableObject = Notify views on data change [OK]

Hint: ObservableObject = data change notifier for views [OK]

Common Mistakes:

• Confusing ObservableObject with view creation
• Thinking it handles user input directly
• Assuming it manages navigation

2. Which of the following is the correct way to mark a property inside an ObservableObject class so that changes notify the UI?

easy

A. @State var count: Int = 0

B. @Published var count: Int = 0

C. var count: Int = 0

D. @ObservedObject var count: Int = 0

Solution

1. Step 1: Identify property wrapper for change notification

   Inside an ObservableObject, properties that should notify views must use @Published.

2. Step 2: Check other options

   @State is for views, @ObservedObject is for view properties, and plain var does not notify.

3. Final Answer:

   @Published var count: Int = 0 -> Option B

4. Quick Check:

   Use @Published for ObservableObject properties [OK]

Hint: Use @Published to notify UI from ObservableObject [OK]

Common Mistakes:

• Using @State inside ObservableObject class
• Forgetting @Published wrapper
• Confusing @ObservedObject with property wrapper

3. Given this code snippet, what will be printed when the button is tapped once?

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

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

  var body: some View {
    Button("Tap") {
      counter.count += 1
      print(counter.count)
    }
  }
}

medium

A. 1

B. Button tapped

C. 0

D. Compilation error

Solution

1. Step 1: Understand initial value and increment

   The count starts at 0 and increments by 1 when the button is tapped.

2. Step 2: Check print output after increment

   After increment, count is 1, so print outputs 1.

3. Final Answer:

   1 -> Option A

4. Quick Check:

   Increment then print = 1 [OK]

Hint: Increment before print means output is 1 [OK]

Common Mistakes:

• Printing before increment
• Confusing initial value with updated value
• Assuming compilation error due to ObservableObject

4. Identify the error in this ObservableObject class that prevents UI updates:

class TimerData: ObservableObject {
  var seconds = 0

  func tick() {
    seconds += 1
  }
}

medium

A. Missing @Published on seconds property

B. Class must inherit from NSObject

C. tick() must be marked as @Published

D. ObservableObject requires struct, not class

Solution

1. Step 1: Check property change notification

   The seconds property is not marked with @Published, so changes won't notify views.

2. Step 2: Verify other options

   ObservableObject does not require NSObject inheritance, methods can't be @Published, and it must be a class.

3. Final Answer:

   Missing @Published on seconds property -> Option A

4. Quick Check:

   @Published missing = no UI update [OK]

Hint: Properties must be @Published to notify UI [OK]

Common Mistakes:

• Thinking methods can be @Published
• Believing ObservableObject needs NSObject
• Confusing class and struct requirements

5. You want to create a SwiftUI view that updates automatically when a user's name changes. Which combination correctly connects the ObservableObject and the view?

class UserData: ObservableObject {
  @Published var name: String = ""
}

struct UserView: View {
  // What property wrapper and type should be used here?
  var userData: UserData

  var body: some View {
    Text(userData.name)
  }
}

hard

A. @StateObject var userData: UserData

B. @State var userData: UserData

C. @Published var userData: UserData

D. @ObservedObject var userData: UserData

Solution

1. Step 1: Understand property wrappers for ObservableObject in views

   Use @ObservedObject when the view receives an ObservableObject from outside and watches it.

2. Step 2: Differentiate @StateObject and @ObservedObject

   @StateObject is for creating and owning the object inside the view; @ObservedObject is for observing an existing object.

3. Final Answer:

   @ObservedObject var userData: UserData -> Option D

4. Quick Check:

   Observe external ObservableObject with @ObservedObject [OK]

Hint: Use @ObservedObject to watch external ObservableObject [OK]

Common Mistakes:

• Using @State for ObservableObject
• Confusing @StateObject with @ObservedObject
• Trying to use @Published in views