swiftui how to store current view in variable

Lussy04

3 min read

·

25-01-2025

31

0

Share

SwiftUI doesn't directly offer a way to store the "current view" as a simple variable in the same way you might in UIKit. The concept of a "current view" is handled differently within SwiftUI's declarative paradigm. Instead of managing views directly, you manage the state that determines which view is displayed. This state change triggers SwiftUI to update the view hierarchy.

This article explores several approaches to effectively manage and, in a sense, "store" the currently displayed view in your SwiftUI application. We'll cover techniques using @State, @ObservedObject, and @EnvironmentObject for different scenarios.

Understanding SwiftUI's State Management

Before diving into solutions, let's reiterate a key aspect of SwiftUI: views are a function of your app's state. When the state changes, SwiftUI automatically updates the view. Therefore, instead of storing the view itself, we store the data that dictates which view should be rendered.

Method 1: Using @State for Simple View Switching

This is the simplest approach, suitable for situations where you need to switch between a small number of views based on a simple boolean or enum value.

import SwiftUI

struct ContentView: View {
    @State private var isShowingDetailView: Bool = false

    var body: some View {
        if isShowingDetailView {
            DetailView()
        } else {
            MainView()
                .onTapGesture {
                    isShowingDetailView = true
                }
        }
    }
}

struct MainView: View {
    var body: some View {
        Text("Main View")
    }
}

struct DetailView: View {
    var body: some View {
        Text("Detail View")
    }
}

Here, isShowingDetailView acts as our "current view indicator". Changing its value directly updates which view is rendered. This is ideal for straightforward scenarios but becomes less manageable with a larger number of views.

Method 2: Using @ObservedObject or @EnvironmentObject for Complex State

For more complex applications with multiple views and inter-dependent state, using @ObservedObject or @EnvironmentObject provides better structure and maintainability.

import SwiftUI

class AppState: ObservableObject {
    @Published var currentView: ViewType = .main

    enum ViewType {
        case main, detail, settings
    }
}

struct ContentView: View {
    @ObservedObject var appState: AppState // Or @EnvironmentObject

    var body: some View {
        switch appState.currentView {
        case .main:
            MainView {
                appState.currentView = .detail
            }
        case .detail:
            DetailView {
                appState.currentView = .settings
            }
        case .settings:
            SettingsView {
                appState.currentView = .main
            }
        }
    }
}


struct MainView: View {
    let goToDetailView: () -> Void
    var body: some View {
        Text("Main View")
            .onTapGesture(perform: goToDetailView)
    }
}

struct DetailView: View {
    let goToSettingsView: () -> Void
    var body: some View {
        Text("Detail View")
            .onTapGesture(perform: goToSettingsView)
    }
}

struct SettingsView: View {
    let goBackToMainView: () -> Void
    var body: some View {
        Text("Settings View")
            .onTapGesture(perform: goBackToMainView)
    }
}

In this example, AppState manages the currentView. Using @Published ensures that changes to currentView automatically trigger view updates. @ObservedObject makes the AppState observable within ContentView. @EnvironmentObject allows you to share AppState across your entire app more efficiently. This approach is far more scalable than the @State method for larger projects.

Remember to instantiate and inject the AppState object appropriately in your app's structure.

Choosing the Right Method

The best method depends on your application's complexity:

• @State: Ideal for simple view switching with minimal state.
• @ObservedObject / @EnvironmentObject: Essential for managing complex state and view hierarchies in larger apps. @EnvironmentObject simplifies state sharing across multiple views.

By understanding SwiftUI's state management system, you can effectively manage the views displayed in your application without directly storing the views themselves as variables. Instead, you manage the underlying data that defines which view should be rendered at any given time. This aligns with SwiftUI's declarative approach and results in cleaner, more maintainable code.