iOS16 SwiftUI：MVVM架构下NavigationStack与NavigationPath跨视图导航方案

针对你遇到的跨ViewModel访问NavigationPath的问题，下面提供三种符合MVVM架构的可行方案，每种方案都有具体实现示例：

方案一：依赖注入传递NavigationPath实例 #

这是最贴合MVVM单一职责原则的方式，直接将BaseViewModel中的NavigationPath实例通过构造函数注入到子页面的ViewModel中，保证所有操作的是同一个导航状态对象。

代码示例： #

1. 定义BaseViewModel，持有NavigationPath：

class BaseViewModel: ObservableObject {
    @Published var navigationPath = NavigationPath()
    
    // Base页面跳转逻辑
    func goToPage1() {
        navigationPath.append("Page1")
    }
    
    func goToPage2() {
        navigationPath.append("Page2")
    }
}

2. 定义Page1ViewModel，通过构造函数接收NavigationPath：

class Page1ViewModel: ObservableObject {
    private let navigationPath: Binding<NavigationPath>
    
    // 构造函数注入导航路径绑定
    init(navigationPath: Binding<NavigationPath>) {
        self.navigationPath = navigationPath
    }
    
    // Page1内跳转到Page2的逻辑
    func navigateToPage2() {
        navigationPath.wrappedValue.append("Page2")
    }
}

3. 在BaseView中传递NavigationPath给Page1：

struct BaseView: View {
    @StateObject private var vm = BaseViewModel()
    
    var body: some View {
        NavigationStack(path: $vm.navigationPath) {
            VStack {
                Button("跳转到Page1") {
                    vm.goToPage1()
                }
            }
            .navigationDestination(for: String.self) { destination in
                if destination == "Page1" {
                    Page1View(vm: Page1ViewModel(navigationPath: $vm.navigationPath))
                } else if destination == "Page2" {
                    Page2View()
                }
            }
        }
    }
}

方案二：全局导航状态管理 #

如果页面层级较复杂，依赖注入会显得繁琐，可以将NavigationPath封装到一个全局的ObservableObject类中，所有ViewModel都通过访问这个单例来操作导航状态。

代码示例： #

1. 创建全局导航状态类：

class NavigationState: ObservableObject {
    static let shared = NavigationState()
    @Published var navigationPath = NavigationPath()
    
    private init() {} // 保证单例
    
    // 通用导航方法
    func push(_ destination: any Hashable) {
        navigationPath.append(destination)
    }
    
    func pop() {
        navigationPath.removeLast()
    }
    
    func popToRoot() {
        navigationPath.removeLast(navigationPath.count)
    }
}

2. 所有ViewModel直接使用这个单例：

class BaseViewModel: ObservableObject {
    private let navState = NavigationState.shared
    
    func goToPage1() {
        navState.push("Page1")
    }
}

class Page1ViewModel: ObservableObject {
    private let navState = NavigationState.shared
    
    func navigateToPage2() {
        navState.push("Page2")
    }
}

3. 在根视图绑定全局导航状态：

struct BaseView: View {
    @StateObject private var navState = NavigationState.shared
    
    var body: some View {
        NavigationStack(path: $navState.navigationPath) {
            // ... 页面内容
            .navigationDestination(for: String.self) { destination in
                // ... 对应页面跳转
            }
        }
    }
}

方案三：通过回调闭包传递导航事件 #

如果不想让子ViewModel直接持有NavigationPath（避免状态耦合），可以在子ViewModel中定义回调闭包，将导航动作委托给父ViewModel或视图处理。

代码示例： #

1. 定义Page1ViewModel，包含导航回调闭包：

class Page1ViewModel: ObservableObject {
    var onNavigateToPage2: (() -> Void)?
    
    func navigateToPage2() {
        onNavigateToPage2?()
    }
}

2. 在BaseView中为Page1ViewModel赋值闭包：

struct BaseView: View {
    @StateObject private var vm = BaseViewModel()
    
    var body: some View {
        NavigationStack(path: $vm.navigationPath) {
            // ... 页面内容
            .navigationDestination(for: String.self) { destination in
                if destination == "Page1" {
                    let page1VM = Page1ViewModel()
                    page1VM.onNavigateToPage2 = {
                        self.vm.goToPage2()
                    }
                    Page1View(vm: page1VM)
                }
                // ... 其他页面
            }
        }
    }
}

额外建议 #

• 为了保证类型安全，建议用枚举定义所有导航目的地，替代示例中的String：

enum Destination: Hashable {
    case page1
    case page2
}

这样在append和navigationDestination中都使用枚举值，避免字符串拼写错误。

• 操作NavigationPath时，注意回退逻辑的正确性，比如removeLast()是回退一页，removeLast(count)可以直接回退到指定层级。

内容的提问来源于stack exchange，提问作者Ákos Morvai