如何在NavigationStack中程序化回退指定数量的视图？

当你需要在NavigationStack的深层视图（第4/5层级）一次性回退3-4个视图时，最可靠且优雅的方式是利用NavigationPath绑定直接控制导航层级，避免逐个调用dismiss的繁琐操作。

方法1：使用NavigationPath精准控制导航层级 #

NavigationStack支持绑定一个NavigationPath对象，这个对象本质是存储导航历史的数组，直接修改数组长度就能实现批量回退。

实现步骤 #

1. 在根视图中创建@State修饰的NavigationPath变量
2. 将NavigationStack与该path绑定
3. 通过navigationDestination配置路径对应的目标视图
4. 在子视图中传递path的绑定，直接修改数组完成回退

修改后的完整代码示例 #

struct MainMenu: View {
    // 存储导航历史的路径对象
    @State private var navigationPath = NavigationPath()
    
    var body: some View {
        // 将NavigationStack与path绑定
        NavigationStack(path: $navigationPath) {
            VStack{
                List{
                    // 使用value类型的NavigationLink，配合navigationDestination
                    NavigationLink(value: "invoice") {
                        MenuButton(choice: "invoice")
                    }
                }
                // 可选：显示当前层级，方便调试
                Text("当前层级数: \(navigationPath.count)")
                    .padding()
            }
            // 配置路径对应的目标视图
            .navigationDestination(for: String.self) { value in
                switch value {
                case "invoice":
                    InvoiceMenu(navigationPath: $navigationPath)
                case "step2":
                    Step2View(navigationPath: $navigationPath)
                case "step3":
                    Step3View(navigationPath: $navigationPath)
                case "step4":
                    Step4View(navigationPath: $navigationPath)
                default:
                    EmptyView()
                }
            }
        }
    }
}

// 子视图：InvoiceMenu，接收导航路径绑定
struct InvoiceMenu: View {
    @Binding var navigationPath: NavigationPath
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Invoice Menu（第2层级）")
            NavigationLink(value: "step2") {
                Text("进入第二步")
            }
            NavigationLink(value: "step3") {
                Text("进入第三步")
            }
        }
    }
}

// 层级3视图
struct Step2View: View {
    @Binding var navigationPath: NavigationPath
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Step 2（第3层级）")
            NavigationLink(value: "step4") {
                Text("进入第四步")
            }
        }
    }
}

// 层级3视图
struct Step3View: View {
    @Binding var navigationPath: NavigationPath
    
    var body: some View {
        Text("Step 3（第3层级）")
    }
}

// 层级4视图，实现回退操作
struct Step4View: View {
    @Binding var navigationPath: NavigationPath
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Step 4（第4层级）")
            
            // 回退3步到第1层级（根视图）
            Button("回退3步到根") {
                guard navigationPath.count >= 3 else {
                    navigationPath.removeAll()
                    return
                }
                navigationPath.removeLast(3)
            }
            
            // 回退2步到第2层级（InvoiceMenu）
            Button("回退2步到InvoiceMenu") {
                guard navigationPath.count >= 2 else {
                    navigationPath.removeAll()
                    return
                }
                navigationPath.removeLast(2)
            }
        }
    }
}

struct MenuButton: View {
    let choice: String
    var body: some View {
        Text(choice)
    }
}

方法2：批量调用dismiss（不推荐） #

如果你不想使用NavigationPath，也可以封装一个批量调用dismiss的方法，但这种方式依赖视图 Dismiss 的时机，稳定性不如路径绑定，仅作为备选方案：

extension View {
    func dismissNTimes(_ count: Int, dismiss: DismissAction) {
        guard count > 0 else { return }
        dismiss()
        // 延迟调用避免视图未完成 Dismiss 导致的问题
        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
            dismissNTimes(count - 1, dismiss: dismiss)
        }
    }
}

// 在子视图中使用
struct Step4View: View {
    @Environment(\.dismiss) private var dismiss
    
    var body: some View {
        Button("回退3步") {
            dismissNTimes(3, dismiss: dismiss)
        }
    }
}

总结 #

优先选择NavigationPath绑定的方式，它能精准控制导航层级，代码更简洁且稳定，完全避免逐个关闭视图的繁琐操作。

内容的提问来源于stack exchange，提问作者Bartender1382