@Binding for child communication in iOS Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What happens when a child view modifies a @Binding variable?

Consider a SwiftUI parent view passing a @State variable as a @Binding to a child view. What is the effect when the child view modifies this @Binding variable?

iOS Swift

struct ParentView: View {
  @State private var count = 0
  var body: some View {
    ChildView(count: $count)
  }
}

struct ChildView: View {
  @Binding var count: Int
  var body: some View {
    Button("Increment") {
      count += 1
    }
  }
}

A The parent view's count variable updates and the UI refreshes accordingly.

B Only the child view's count updates; the parent view remains unchanged.

C The count variable does not change because @Binding is read-only.

D The app crashes because @Binding cannot be modified in the child.

💡 Hint

Think about how @Binding connects child and parent state in SwiftUI.

@Binding creates a two-way connection between the parent and child views. When the child modifies the @Binding variable, it updates the parent's @State variable, causing the UI to refresh.

📝 Syntax

intermediate

Identify the correct way to declare a @Binding variable in a child view

Which of the following is the correct syntax to declare a @Binding variable named isOn of type Bool in a SwiftUI child view?

A @State var isOn: Bool

B var isOn: Binding<Bool>

C @Binding var isOn: Bool

D let isOn: Bool

💡 Hint

Remember that @Binding is a property wrapper used to declare a binding variable.

The correct syntax uses the @Binding property wrapper with var. Option C declares a Binding type but not as a property wrapper, which is incorrect for a child view's binding variable.

❓ lifecycle

advanced

When does a SwiftUI view update after a @Binding variable changes?

In SwiftUI, after a child view modifies a @Binding variable, when does the parent view re-render?

A The parent view never re-renders automatically from @Binding changes.

B After the current run loop completes and SwiftUI schedules a view update.

C Immediately after the @Binding variable changes, before the current run loop ends.

D Only when the parent view explicitly calls <code>setNeedsDisplay()</code>.

💡 Hint

Think about how SwiftUI batches view updates for performance.

SwiftUI batches state changes and schedules view updates after the current run loop completes to optimize performance. So the parent view re-renders shortly after the @Binding variable changes, not immediately.

🔧 Debug

advanced

Why does this child view fail to update the parent state via @Binding?

Given the code below, why does tapping the button not update the parent view's text?

iOS Swift

struct ParentView: View {
  @State private var text = "Hello"
  var body: some View {
    ChildView(text: text)
  }
}

struct ChildView: View {
  @Binding var text: String
  var body: some View {
    Button("Change") {
      text = "World"
    }
  }
}

A The parent passes a value instead of a binding; it should pass $text.

B The child view's @Binding variable is missing the @State wrapper.

C The button action is not called because the label is incorrect.

D The parent view's text variable is declared with @State, which is incompatible with @Binding.

💡 Hint

Check how the parent passes the variable to the child.

The parent must pass a binding using the $ prefix (e.g., $text) to connect the child's @Binding variable. Passing just text sends a copy, so changes in the child don't affect the parent.

🧠 Conceptual

expert

What is the main advantage of using @Binding for child communication in SwiftUI?

Why is @Binding preferred for passing data from a parent to a child view when the child needs to modify the parent's state?

A It disables the parent's state updates while the child is active to avoid conflicts.

B It copies the parent's state to the child, preventing accidental changes to the parent.

C It forces the child to manage its own independent state, improving modularity.

D It creates a two-way connection allowing the child to update the parent's state directly, keeping UI in sync.

💡 Hint

Think about how data flows and updates between views in SwiftUI.

@Binding allows the child view to read and write the parent's state directly, enabling synchronized UI updates without duplicating state or complex callbacks.