macOS SwiftUI中如何在两个视图分支间传递事件？

这在SwiftUI里其实很常见，核心思路是数据驱动状态共享或者闭包直接传递事件，代替AppKit依赖的响应链机制。我给你两种常用的实现方案，你可以根据项目复杂度选择：

方案一：使用ObservableObject（ViewModel）管理状态（推荐用于复杂场景） #

这种方式适合当你有更多业务逻辑（比如元素的删除、排序、搜索状态管理等）时使用，通过一个共享的ViewModel来统一管理数据，让两个子视图都能访问和修改状态。

步骤1：定义ViewModel和数据模型 #

import SwiftUI

// 元素模型，遵循Identifiable方便列表展示
struct Element: Identifiable {
    let id = UUID()
    let name: String
    // 可添加你的其他属性，比如描述、图标等
}

// 共享的ViewModel，用@Published标记需要监听的属性
class ElementViewModel: ObservableObject {
    // 元素列表，@Published会自动通知视图刷新
    @Published var elements: [Element] = []
    
    // 添加元素的方法，统一处理添加逻辑
    func addElement(_ element: Element) {
        // 可添加重复检查等额外逻辑
        if !elements.contains(where: { $0.name == element.name }) {
            elements.append(element)
        }
    }
}

步骤2：父视图注入ViewModel #

在父视图中创建ViewModel实例，然后传递给两个子视图：

struct MainContainerView: View {
    // 用@StateObject确保ViewModel在视图生命周期内保持唯一
    @StateObject private var viewModel = ElementViewModel()
    
    var body: some View {
        // 假设用HStack或SplitView布局两个分支视图
        HStack(spacing: 0) {
            ElementListView(viewModel: viewModel)
                .frame(width: 300)
            
            FiltersView(viewModel: viewModel)
        }
    }
}

步骤3：实现ElementListView #

直接绑定ViewModel的elements数组，自动响应数据变化：

struct ElementListView: View {
    // 用@ObservedObject监听ViewModel的变化
    @ObservedObject var viewModel: ElementViewModel
    
    var body: some View {
        List(viewModel.elements) { element in
            Text(element.name)
                .padding(.vertical, 8)
        }
        .navigationTitle("My Elements")
        .listStyle(.sidebar)
    }
}

步骤4：实现FiltersView和FilterRow #

在FilterRow的点击事件中调用ViewModel的添加方法：

struct FiltersView: View {
    @ObservedObject var viewModel: ElementViewModel
    @State private var searchText = ""
    
    // 模拟搜索结果，替换成你的实际搜索逻辑
    private var searchResults: [Element] {
        if searchText.isEmpty {
            return []
        } else {
            return [
                Element(name: "New Element A"),
                Element(name: "New Element B"),
                Element(name: "New Element C")
            ]
        }
    }
    
    var body: some View {
        VStack(spacing: 0) {
            TextField("Search for elements...", text: $searchText)
                .padding()
                .background(Color(.systemGray6))
            
            List(searchResults) { result in
                FilterRow(element: result) {
                    // 点击行时调用ViewModel的添加方法
                    viewModel.addElement(result)
                }
            }
            .listStyle(.plain)
        }
        .navigationTitle("Add Elements")
    }
}

struct FilterRow: View {
    let element: Element
    // 用闭包接收点击事件
    let onTap: () -> Void
    
    var body: some View {
        HStack {
            Text(element.name)
                .font(.subheadline)
            Spacer()
            Image(systemName: "plus.circle.fill")
                .foregroundColor(.blue)
        }
        .padding(.vertical, 6)
        .contentShape(Rectangle()) // 让整行都能响应点击
        .onTapGesture(perform: onTap)
    }
}

方案二：直接用闭包传递事件（适合简单场景） #

如果你的业务逻辑很简单，不需要额外的状态管理，直接通过闭包把点击事件从FilterRow传递到父视图，再更新元素列表即可。

父视图实现 #

struct MainContainerView: View {
    // 直接在父视图维护元素列表
    @State private var elements: [Element] = []
    
    var body: some View {
        HStack(spacing: 0) {
            ElementListView(elements: $elements)
                .frame(width: 300)
            
            FiltersView(onElementSelected: { newElement in
                // 在这里处理添加逻辑
                if !elements.contains(where: { $0.name == newElement.name }) {
                    elements.append(newElement)
                }
            })
        }
    }
}

ElementListView用Binding接收数据 #

struct ElementListView: View {
    @Binding var elements: [Element]
    
    var body: some View {
        List(elements) { element in
            Text(element.name)
                .padding(.vertical, 8)
        }
        .navigationTitle("My Elements")
        .listStyle(.sidebar)
    }
}

FiltersView和FilterRow传递闭包 #

struct FiltersView: View {
    let onElementSelected: (Element) -> Void
    @State private var searchText = ""
    
    private var searchResults: [Element] {
        // 替换成你的实际搜索逻辑
        searchText.isEmpty ? [] : [
            Element(name: "Simple Element 1"),
            Element(name: "Simple Element 2")
        ]
    }
    
    var body: some View {
        VStack(spacing: 0) {
            TextField("Search...", text: $searchText)
                .padding()
                .background(Color(.systemGray6))
            
            List(searchResults) { result in
                FilterRow(element: result) {
                    onElementSelected(result)
                }
            }
            .listStyle(.plain)
        }
        .navigationTitle("Add Elements")
    }
}

// FilterRow的实现和方案一一致，通过闭包接收点击事件
struct FilterRow: View {
    let element: Element
    let onTap: () -> Void
    
    var body: some View {
        HStack {
            Text(element.name)
                .font(.subheadline)
            Spacer()
            Image(systemName: "plus.circle.fill")
                .foregroundColor(.blue)
        }
        .padding(.vertical, 6)
        .contentShape(Rectangle())
        .onTapGesture(perform: onTap)
    }
}

为什么不用响应链？ #

SwiftUI的设计核心是数据驱动UI，所有的视图更新都依赖状态变化，而不是像AppKit那样通过响应链传递事件。上面的两种方案都是SwiftUI的常规做法：ViewModel适合复杂状态管理，闭包适合简单的事件传递，都能很好地解决你的跨视图分支事件传递问题。

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