Using the “Just” command in SwiftUI with Combine

In this example, we’re building a SwiftUI view that uses Combine’s Just publisher to emit a single message. The view is simple but demonstrates key concepts of SwiftUI and Combine working together.

import SwiftUI
import Combine

struct JustExampleView: View {
    // State variable to store the received value
    @State private var message: String = "Waiting for message..."
    
    // State to hold the cancellable subscription
    @State private var cancellable: AnyCancellable?
    
    var body: some View {
        VStack {
            Text("Just Publisher Example")
                .font(.headline)
                .padding()
            
            Text(message) // Display the received message
                .font(.title)
                .padding()
            
            Button("Get Message") {
                getMessage()
            }
            .padding()
            .background(Color.blue)
            .foregroundColor(.white)
            .cornerRadius(8)
        }
        .onDisappear {
            // Cancel the subscription if the view disappears
            cancellable?.cancel()
        }
    }
    
    private func getMessage() {
        // Using the Just publisher to send a single message
        cancellable = Just("Hello from Just!")
            .sink { value in
                message = value
            }
    }
}

struct JustExampleView_Previews: PreviewProvider {
    static var previews: some View {
        JustExampleView()
    }
}

Code Breakdown

1. State Variables:
   • @State private var message: String: This @State variable holds the message that will be displayed in the view. Initially, it’s set to "Waiting for message...", which acts as a placeholder until the user triggers the Just publisher.
   • @State private var cancellable: AnyCancellable?: This @State variable holds a reference to the subscription created by the Just publisher. We use AnyCancellable to store and cancel the subscription as needed.
2. View Structure:
   • The VStack container arranges the elements vertically. Inside it, we have:
     • A title Text view with the label "Just Publisher Example" to introduce the purpose of the view.
     • A Text view that displays the message variable, updated when the Just publisher emits a new message.
     • A Button labeled "Get Message", which triggers the getMessage() function to start the Just publisher.
3. getMessage() Function:
   • Inside getMessage(), we define a Just publisher with the message "Hello from Just!".
   • We call .sink on this publisher to receive the emitted value. The sink operator provides the emitted value (value in this case) as an argument, which we assign to message. When message is updated, SwiftUI automatically refreshes the view to show the new text.
4. onDisappear Modifier:
   • The .onDisappear modifier cancels the cancellable subscription when the view disappears, freeing up resources. This is a good practice, as it prevents unnecessary memory usage if the view is no longer on screen.

How the Just Publisher Works Here

The Just publisher emits a single value, "Hello from Just!", immediately upon being created. This value is then “sunk” into the sink subscriber, updating message with the new text. Since SwiftUI listens to changes in @State properties like message, it refreshes the view to show the updated message as soon as it’s received.

Summary

This example demonstrates a few key points:

• Using Just: Just is perfect for scenarios where we need a single value to be emitted immediately.
• Using Combine with SwiftUI: By updating a @State property, we ensure that the UI reacts automatically to changes in the data.
• Resource Management with AnyCancellable: Holding a reference to the subscription with AnyCancellable and canceling it when the view disappears shows how we can manage Combine subscriptions effectively in SwiftUI.

This simple example illustrates the basics of using Combine in SwiftUI, making it easier to handle one-off data emissions and update the UI in a reactive, declarative style.

Why not just set the variable value?

While directly assigning a value like message = "ABC 1234" within a button’s action is straightforward, using Combine’s Just and sink approach can be advantageous in cases where reactive programming and more complex data flows are needed. Here are some reasons why this approach can be more powerful:

1. Consistency in Reactive Data Flow: If your app already uses Combine to handle various asynchronous tasks or data flows, maintaining a consistent reactive pattern across the app simplifies code readability and maintenance. Using Just to emit a single value allows you to keep data updates consistent with other parts of the app, which may use other Combine publishers.
2. Greater Flexibility with Operators: Combine offers numerous operators, such as map, filter, catch, and retry, which allow you to transform, filter, and handle errors within a data stream. By using Just and sink, you can easily add these operators as your needs grow. For instance, if you later need to transform or validate the message, you can simply chain these operators to the existing Just publisher.
3. Testing and Mocking Simplification: Just is particularly useful in testing environments. You can use Just to simulate various data inputs, such as testing different network responses without having to change the structure of your code. This approach is helpful in unit tests, where you might need to test how different values or data types affect your app.
4. Seamless Data Chaining: Combine allows you to chain publishers, making it easier to work with multiple data sources or to combine static data with dynamic data updates. Starting with a Just publisher allows you to chain it with other publishers or to combine it with network responses, user input streams, or other app data, all within the same flow.

Using Just and sink may seem like extra work in simple cases, but it provides flexibility, consistency, and a strong foundation for more complex scenarios. As your app scales, the reactive approach offers cleaner and more maintainable solutions for handling data and events.