Swift中如何为@Published数组触发objectWillChange？

核心原因 #

1. @Published的触发逻辑：@Published仅在属性的值本身发生变化时才会发送更新事件。数组是值类型，只有当整个数组实例（比如重新赋值、增删元素）改变时，@Published才会触发；而数组元素（引用类型）内部的状态变化，不会导致数组本身的实例变化，所以@Published不会自动响应。
2. objectWillChange的归属：objectWillChange是ObservableObject协议的属性，只有ObservableObject的实例（比如你的GlobalData）才有这个方法，数组本身不是ObservableObject，自然没有objectWillChange，你之前调用的是GlobalData实例的更新事件，而非数组@Published属性的发布者。

解决方案 #

方案1：手动触发数组的@Published更新

通过重新赋值数组（生成新的数组实例）来触发@Published的发布事件，同时修复原代码中重复订阅的内存泄漏问题：

final class GlobalData: ObservableObject {
    static let shared = GlobalData()
    
    var cancellables = [AnyCancellable]()
    @Published private(set) var lists: [WishList] = [] {
        didSet {
            // 先清空旧订阅，避免内存泄漏
            cancellables.removeAll()
            lists.forEach { list in
                list.objectWillChange
                    .sink { [weak self] _ in
                        // 重新赋值数组，触发@Published的更新
                        guard let self = self else { return }
                        self.lists = self.lists
                    }
                    .store(in: &cancellables)
            }
        }
    }
}

当数组元素内部变化时，重新赋值数组会生成新的数组实例，满足@Published的触发条件，视图的onChange(of: globalData.lists)会收到回调。

方案2：将数组包装为ObservableObject

创建一个专门的数组包装类，让它成为ObservableObject，统一处理元素变化的事件转发：

// 通用的可观察数组包装类
final class ObservableArray<T: ObservableObject>: ObservableObject {
    var elements: [T] {
        didSet {
            setupElementSubscriptions()
        }
    }
    
    private var cancellables = [AnyCancellable]()
    
    init(elements: [T]) {
        self.elements = elements
        setupElementSubscriptions()
    }
    
    // 订阅每个元素的变化，触发自身的objectWillChange
    private func setupElementSubscriptions() {
        cancellables.removeAll()
        elements.forEach { element in
            element.objectWillChange
                .sink { [weak self] _ in
                    self?.objectWillChange.send()
                }
                .store(in: &cancellables)
        }
    }
    
    // 可选：封装数组操作方法，方便外部调用
    func append(_ element: T) {
        elements.append(element)
    }
}

// 修改GlobalData
final class GlobalData: ObservableObject {
    static let shared = GlobalData()
    
    @Published private(set) var lists = ObservableArray<WishList>(elements: [])
}

视图中直接监听包装类的元素数组：

.onChange(of: globalData.lists.elements) { _ in
    print("✅", "lists changed")
}

这个方案更模块化，适合复用多个数组场景。

方案3：用CurrentValueSubject手动控制发布

替代@Published，使用CurrentValueSubject手动发送数组更新事件，灵活性更高：

final class GlobalData: ObservableObject {
    static let shared = GlobalData()
    
    var cancellables = [AnyCancellable]()
    
    // 用CurrentValueSubject管理数组状态，手动控制发布
    private let _lists = CurrentValueSubject<[WishList], Never>([])
    // 对外暴露只读的数组访问
    var lists: [WishList] {
        get { _lists.value }
        private set { _lists.send(newValue) }
    }
    
    init() {
        // 监听数组变化，自动订阅元素的更新事件
        _lists
            .sink { [weak self] newLists in
                self?.cancellables.removeAll()
                newLists.forEach { list in
                    list.objectWillChange
                        .sink { _ in
                            // 手动发送当前数组状态，触发视图更新
                            self?._lists.send(newLists)
                        }
                        .store(in: &self!.cancellables)
                }
            }
            .store(in: &cancellables)
    }
    
    // 对外提供修改数组的方法
    func updateLists(_ newLists: [WishList]) {
        lists = newLists
    }
}

这种方式完全由你控制发布时机，适合复杂的状态管理场景。

关于你的临时方案 #

用UUID标记变化的方式是可行的，但确实不够直观，上面的方案都能直接触发数组的状态更新，更符合SwiftUI的响应式设计逻辑。

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