Скачать или смотреть Understanding Codable Conformance with @ Published Arrays in Swift

A deep dive into how Swift's `Codable` protocol interacts with `@ Published` properties in SwiftUI for efficient data handling.
---
This video is based on the question https://stackoverflow.com/q/64201957/ asked by the user 'Adam' ( https://stackoverflow.com/u/14390359/ ) and on the answer https://stackoverflow.com/a/64223665/ provided by the user 'tphduy' ( https://stackoverflow.com/u/6387995/ ) 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: Codable conformance at @ Published array of a codable-conformed Struct

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 Codable Conformance with @ Published Arrays in Swift

When building applications in Swift, particularly with SwiftUI, you might encounter the need to handle data more efficiently, especially when working with remote data sources like JSON APIs. This brings us to the concept of the Codable protocol and the @ Published property wrapper—a combination that can lead to confusion. In this article, we will demystify the issue of making an array of Codable structs conform to Codable when wrapped in @ Published and explain the internal workings of these protocols in a straightforward manner.

The Problem: Understanding Codable and @ Published

Suppose you are creating an application that fetches a list of friends, similar to a social networking platform. You might define a user and their friends using the following User struct:

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

Here, the User struct and its nested Friend struct both conform to Codable, allowing them to be easily encoded and decoded from JSON.

Next, you attempt to store an array of User objects within another class, like so:

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

While UsersArrayClass conforms to ObservableObject, you encounter confusion when you try to make it conform to Codable. Why doesn’t userArray, which contains User objects, also conform to Codable?

Why @ Published Does Not Conform to Codable

The crux of the issue lies in the fact that the @ Published property wrapper does not currently conform to Codable. Here’s what happens behind the scenes:

Property Wrappers and Protocol Conformance: The Published wrapper is a custom structure used by SwiftUI to enable reactive programming. By default, property wrappers like @ Published don’t automatically inherit the protocol conformance of the underlying type. This means that even if the items wrapped in a @ Published array conform to Codable, the wrapper itself does not.

The error you will see in Xcode looks something like this:

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

Manual Conformance: If you were to try and extend Published to conform to Codable with a generic proof, it wouldn’t work as you might expect due to Swift’s strict type constraints:

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

This kind of extension fails because it is trying to manipulate the internal workings of a property wrapper which has its own intricacies.

The Solution: Alternative Methods to Handle Data

While it may be tempting to think of moving everything into Core Data or finding a workaround to make UsersArrayClass conform to Codable, here are a few streamlined approaches you could consider:

Use a Regular Array: Instead of using @ Published directly on an array you need to encode/decode, you can use a separate Codable array. Handle network calls and parsing within a function, then assign the result to userArray:

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

Encapsulate JSON Logic: Create a function to handle the encoding/decoding separately, so that your UsersArrayClass maintains its reactive properties without clashing with Codable:

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

Conclusion

Understanding how Codable and @ Published interact is vital for building dynamic Swift applications that handle data smoothy. As you’ve learned, the issue isn’t with your data structures; it’s a limitation of the property wrapper in Swift. By adjusting how you manage your data encoding and decoding, you can effectively bypass the limitations imposed by @ Published and continue building interactive and data-driven apps. Happy coding!