Скачать или смотреть Understanding the Difference Between Struct and Class in Swift and the Issue with SwiftUI Updates

Discover how to resolve the behaviors of classes and structs in Swift while ensuring that your SwiftUI interface correctly updates when your data changes.
---
This video is based on the question https://stackoverflow.com/q/68786142/ asked by the user 'Thomas' ( https://stackoverflow.com/u/6035560/ ) and on the answer https://stackoverflow.com/a/68786212/ provided by the user 'vadian' ( https://stackoverflow.com/u/5044042/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Difference between struct and class in Swift, also SwiftUI not updating

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding the Difference Between Struct and Class in Swift and the Issue with SwiftUI Updates

When you’re developing applications with Swift and SwiftUI, you may find yourself frequently choosing between using a struct or a class. But what are the fundamental differences between the two, and why might this cause issues with updating your UI? Let’s explore these concepts in detail, using a practical example to illustrate these differences and resolve any related issues you might encounter.

The Problem Overview

You might have run into a scenario similar to the one described below:

You have a struct named PersonStruct and a class named PersonClass.

Both classes have a method called changeName that modifies the name property.

Despite trying to change the names using the method, you found that the UI does not update accordingly, especially for the struct.

You thought that using SwiftUI would automatically refresh the UI when data changes, but that hasn't been the case. So, what's going wrong?

Difference Between Struct and Class in Swift

Memory Management

Structs

Value types: When you assign or pass around a struct, its data is copied.

This means changes to one instance do not affect another instance; each operates on its own copy.

Classes

Reference types: When you assign or pass around a class, you’re dealing with references to the same instance.

Changes to one reference will affect all references pointing to that instance.

Mutability

For a struct, you must define methods that modify its properties as mutating.

Classes don't require this keyword, since their properties can be modified directly without a mutability constraint.

Observability in SwiftUI

When using SwiftUI, it's crucial to understand how data updates trigger UI changes:

-State: Used with structs to indicate that the view should re-render when the state changes.

-ObservableObject and -Published: Used with classes to notify SwiftUI of changes in data that should affect the UI.

The Solution

From our example, here are the adjustments needed to solve the problem:

Update the PersonStruct

Remove the -State property wrapper.

Make the changeName method mutating.

Here’s the corrected code for PersonStruct:

[[See Video to Reveal this Text or Code Snippet]]

Update the PersonClass

Adopt ObservableObject to make it observable.

Use -Published with the property name.

Here’s the corrected code for PersonClass:

[[See Video to Reveal this Text or Code Snippet]]

Integrating into the View

In your ContentView, you need to declare the data types properly:

[[See Video to Reveal this Text or Code Snippet]]

By following these adjustments, person1 (the struct) should now properly reflect changes when its changeName function is called, and the UI will update correctly.

Conclusion

Understanding the difference between struct and class in Swift is pivotal for efficient programming, especially when using SwiftUI. Properly applying -State, -StateObject, and -Published will ensure your UI updates as expected. By modifying both PersonStruct and PersonClass, you can maintain effective data flow in your SwiftUI applications.

Now that you’ve learned the differences and how to correctly implement updates, you can avoid the common pitfalls that lead to frustration during development. Happy coding!