Binding vs Bindable in Observation Framework | What’s the difference? | Part 4

Summary

In this video, the presenter breaks down the difference between `bindable` and `binding` in SwiftUI, explaining when to use each one. The `bindable` property wrapper is used for passing down observable objects and modifying their properties, while `binding` is more focused on managing specific properties without needing the full object. The video provides practical examples to demonstrate how these tools are used to manage data flow in SwiftUI views. Key takeaways include using `bindable` for full object access and `binding` for focused state management, promoting efficient, clean code practices.

Takeaways

• 😀 Bindings in SwiftUI allow views to read and write to specific properties of a model.
• 😀 `Bindable` property wrapper (introduced in iOS 17) marks a model as observable and allows views to access and modify the entire object.
• 😀 The `Binding` property wrapper is used when you need to access only a subset of a model's properties, keeping the view lightweight.
• 😀 `Bindable` is useful when you need to pass an entire observable object to a child view for both reading and writing.
• 😀 Using `Binding` helps avoid passing large objects when only specific properties are needed by a view.
• 😀 `Bindable` allows a child view to access and modify properties marked with the `@ObservableObject` macro.
• 😀 SwiftUI views like `TextField` and `SecureTextField` have built-in bindings for reading and modifying text input.
• 😀 The use of the `Bindable` wrapper in SwiftUI ensures automatic view refreshes when the observable object's properties change.
• 😀 A good practice in SwiftUI is to only pass the necessary properties to views using `Binding`, instead of passing entire models.
• 😀 The main difference between `Binding` and `Bindable` is that `Binding` is for partial access (specific properties), while `Bindable` provides full access to an observable object.
• 😀 The video explains how to set up both `Binding` and `Bindable` in SwiftUI using code examples, helping developers understand their real-world applications.

Q & A

What is the main focus of this video tutorial?

The main focus of the video is explaining the difference between `Bindable` and `Binding` in SwiftUI, and providing insights on when to use each one.

What is a `Binding` in SwiftUI?

`Binding` is a way to establish a connection between a view and a specific property of an observable object, allowing both reading and writing to that property within the view.

When should you use `Binding` in SwiftUI?

`Binding` should be used when a view only needs to read and modify specific properties of an observable object, such as changing a number or toggling a state.

What does the `Bindable` property wrapper do in SwiftUI?

`Bindable` is a property wrapper introduced in iOS 17 that allows a view to access and modify properties of an observable object. It provides access to the entire object, rather than just individual properties.

How does `Bindable` differ from `Binding` in terms of object access?

`Binding` allows a view to access only specific properties of an object, while `Bindable` allows access to the entire observable object, enabling modifications to multiple properties at once.

Can you give an example of using `Binding` in a SwiftUI view?

In the tutorial, the `EngagementView` uses `Binding` to modify only the `likes` and `dislikes` properties of the model, as these are the only properties required by that view.

What is a good practice when working with SwiftUI views in terms of data passing?

A good practice is to pass only the data a view needs. If a view only requires specific properties, use `Binding`. If it needs access to the entire observable object, use `Bindable`.

Why is `Bindable` useful for passing down observable objects?

`Bindable` is useful when you need to pass down an entire observable object to a child view, allowing the child to read and write multiple properties of that object without explicitly passing each property.

What happens when you use a `Bindable` property wrapper with a view in SwiftUI?

When you use a `Bindable` property wrapper, the view can read and modify properties within the observable object, and changes made to these properties will automatically trigger a view update, causing the view to redraw.

What is the overall rule for using `Binding` versus `Bindable` in SwiftUI?

The general rule is to use `Bindable` when a view needs access to the entire observable object, and use `Binding` when a view only needs to interact with specific properties of the model.