如何用视图接收的对象初始化ViewModel并避免重复请求

针对你遇到的问题，下面提供几种可行的最佳实践方案，既能在ViewModel初始化时触发数据请求，又能避免重复加载：

方案1：通过视图构造器初始化@StateObject #

核心思路是利用视图的自定义初始化器，将item.ID传递给ItemDetailViewModel的初始化方法，同时正确初始化@StateObject的底层存储。

修正ViewModel实现 #

首先调整ItemDetailViewModel，支持通过itemID初始化并异步获取数据：

final class ItemDetailViewModel: ObservableObject {
    @Published var itemDetail: ItemDetail? // 设置为可选，适配异步加载
    private let itemID: String
    
    init(itemID: String) {
        self.itemID = itemID
        // 初始化时直接触发数据请求
        fetchItemDetail()
    }
    
    // 改成异步实现（实际开发中替换为真实网络请求）
    func fetchItemDetail() {
        Task {
            // 模拟网络请求延迟
            try? await Task.sleep(nanoseconds: 1_000_000_000)
            let fetchedDetail = ItemDetail(id: itemID, title: "详情内容")
            
            DispatchQueue.main.async {
                self.itemDetail = fetchedDetail
            }
        }
    }
}

调整详情视图初始化 #

在ItemDetailView中自定义构造器，初始化@StateObject：

struct ItemDetailView: View {
    let item: Item
    @StateObject private var viewModel: ItemDetailViewModel
    
    // 自定义构造器，传递item并初始化ViewModel
    init(item: Item) {
        self.item = item
        // 初始化@StateObject的底层存储
        _viewModel = StateObject(wrappedValue: ItemDetailViewModel(itemID: item.id))
    }
    
    var body: some View {
        VStack {
            if let detail = viewModel.itemDetail {
                Text(detail.title)
                // 其他详情UI组件
            } else {
                ProgressView("加载中...")
            }
        }
        .navigationTitle(item.name)
    }
}

优势：@StateObject会在视图的整个生命周期内保持实例，只要视图未被销毁（比如NavigationLink的push场景，返回后视图会被销毁，再次进入会重新初始化），就不会重复发起请求。

方案2：给ViewModel添加缓存机制 #

如果需要在用户多次进入同一详情页时避免重复请求，可以给ItemDetailViewModel添加静态缓存，优先读取缓存数据：

final class ItemDetailViewModel: ObservableObject {
    @Published var itemDetail: ItemDetail?
    private let itemID: String
    // 静态缓存字典，全局复用已获取的详情数据
    private static var detailCache: [String: ItemDetail] = [:]
    
    init(itemID: String) {
        self.itemID = itemID
        // 先检查缓存，存在则直接赋值
        if let cachedDetail = Self.detailCache[itemID] {
            self.itemDetail = cachedDetail
        } else {
            fetchItemDetail()
        }
    }
    
    func fetchItemDetail() {
        Task {
            try? await Task.sleep(nanoseconds: 1_000_000_000)
            let fetchedDetail = ItemDetail(id: itemID, title: "详情内容")
            
            DispatchQueue.main.async {
                // 写入缓存
                Self.detailCache[itemID] = fetchedDetail
                self.itemDetail = fetchedDetail
            }
        }
    }
}

优势：即使视图被销毁后重新创建，ViewModel会先读取缓存，无需重复发起网络请求，适合需要跨会话缓存的场景。

方案3：父ViewModel统一管理缓存 #

如果需要在列表视图和详情视图之间共享缓存，可以让ItemListViewModel维护缓存字典，详情ViewModel依赖父ViewModel获取数据：

调整列表ViewModel #

final class ItemListViewModel: ObservableObject {
    @Published var items: [Item] = []
    // 缓存详情数据
    private var detailCache: [String: ItemDetail] = [:]
    
    init() {
        fetchItems()
    }
    
    func fetchItems() {
        // 模拟获取列表数据
        items = [Item(id: "1", name: "项目1"), Item(id: "2", name: "项目2")]
    }
    
    // 提供带缓存的详情获取方法
    func getDetail(for itemID: String) async -> ItemDetail? {
        if let cached = detailCache[itemID] {
            return cached
        }
        // 模拟网络请求
        try? await Task.sleep(nanoseconds: 1_000_000_000)
        let detail = ItemDetail(id: itemID, title: "来自父VM的详情")
        detailCache[itemID] = detail
        return detail
    }
}

调整详情ViewModel和视图 #

final class ItemDetailViewModel: ObservableObject {
    @Published var itemDetail: ItemDetail?
    private let itemID: String
    private let parentViewModel: ItemListViewModel
    
    init(itemID: String, parentViewModel: ItemListViewModel) {
        self.itemID = itemID
        self.parentViewModel = parentViewModel
        fetchItemDetail()
    }
    
    func fetchItemDetail() {
        Task {
            let detail = await parentViewModel.getDetail(for: itemID)
            DispatchQueue.main.async {
                self.itemDetail = detail
            }
        }
    }
}

struct ItemDetailView: View {
    let item: Item
    @StateObject private var viewModel: ItemDetailViewModel
    
    init(item: Item, parentViewModel: ItemListViewModel) {
        self.item = item
        _viewModel = StateObject(wrappedValue: ItemDetailViewModel(itemID: item.id, parentViewModel: parentViewModel))
    }
    
    var body: some View {
        VStack {
            if let detail = viewModel.itemDetail {
                Text(detail.title)
            } else {
                ProgressView("加载中...")
            }
        }
        .navigationTitle(item.name)
    }
}

// 列表视图传递父ViewModel
struct ItemListView: View {
    @StateObject private var viewModel = ItemListViewModel()
    
    var body: some View {
        NavigationStack {
            List {
                ForEach(viewModel.items, id: \.id) { item in
                    NavigationLink {
                        ItemDetailView(item: item, parentViewModel: viewModel)
                    } label: {
                        Text(item.name)
                    }
                }
            }
            .navigationTitle("项目列表")
        }
    }
}

优势：缓存数据在父ViewModel中统一管理，适合列表和详情联动的场景，避免重复请求。

关键注意事项 #

1. 异步请求必须在Task中执行，不能同步阻塞主线程。
2. 更新@Published属性时必须切换回主线程，避免UI更新异常。
3. 如果使用NavigationStack（iOS 16+），返回时视图会被销毁，若要保持ViewModel实例，可以考虑使用.navigationDestination的绑定方式，或者结合缓存机制。

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