Abstracting Navigation in SwiftUI
Currently, implementing navigation between SwiftUI views usually means adding navigation logic that is tightly coupled to a View's body implementation. However, there are things we can do to reduce this coupling, and in this post, Omar demonstrates an approach he uses to decouple navigation logic from Views using some abstraction.
Posted on June 4, 2021
|
Custom Property Wrappers for SwiftUI
A Swift property wrapper adds a layer of separation between code that defines a property and code that managers how a property is stored. By creating custom property wrappers, we write the management code once when we define the wrapper, and then reuse this code when we apply the wrapper to properties. In this post, Dave Delong shares some useful property wrappers that he has come up with while working on SwiftUI.
Posted on April 12, 2021
|
SwiftOnTap - Complete SwiftUI Docs with Examples
This is a cool resource created by members of the Swift community. Its aim, as they put it, is to fill Apple's documentation hole by providing complete SwiftUI documentation with examples. One to bookmark.
Posted on April 6, 2021
|
SwiftUI’s Grid Views
SwiftUI's grid views arrange their child views in a horizontal or vertical grid. However, how they layout their child views can be surprising, and in this post, Florian Kugler from Objc.io examines three particular grid view layout scenarios and explains how the layout algorithm works.
Posted on December 1, 2020
|
SwiftUI View Lifecycle
When working with UI frameworks, it's helpful to understand the lifecycle of the views which make up our interface. Knowing what and when events will occur enables us to perform our actions at the right time. In this post, Vadim Bulavin explores the three phases of the SwiftUI view lifecycle, describing the series of events that happen from the creation of a view to its destruction.
Posted on November 25, 2020
|
How an Hstack Lays out Its Children
As Chris Eidhof states in the introduction to this post, SwiftUI's layout system is, for the most part, intuitive to use. However, there are times when we encounter puzzling layout behaviors, and here Chris provides a detailed explanation of how one particular container view, an HStack, lays out its child views.
Posted on November 23, 2020
|
Debugging SwiftUI: Trials and Tribulations
Working with relatively new frameworks such as SwiftUI means sometimes dealing with subpar debugging tools and seemingly unsolvable bugs. In this post, Reda Lemeden describes the frustration and anxiety he experienced when trying to resolve an issue without much help from the Swift compiler.
Posted on November 15, 2020
|
Hashable SwiftUI bindings
A SwiftUI DisclosureGroup is a view that shows or hides content based on the state of a disclosure control. In this post, Federico Zanetello shows us how to extend DisclosureGroup with a new initializer to provide a similar API to that of the NavigationLink type.
Posted on October 30, 2020
|
Mastering GroupBox in SwiftUI
A Groupbox is a stylized SwiftUI view with an optional label that is associated with a logical grouping of content. In this post, Majid Jabrayilov runs through the basics of using this view type and shows us how we can apply custom styles.
Posted on October 23, 2020
|
Mastering transitions in SwiftUI
In this post, Pavel Zak shows us how to implement custom animation transitions in SwiftUI. As Pavel says, transitions play a vital role in the user experience of an app, and the examples he provides are great starting points for implementing our own transitions.
Posted on October 21, 2020
|