SwiftUI：共享ObservableObject时，单视图拖拽排序不影响其他视图

核心思路是将元素的共享状态（选中高亮）和视图的本地显示排序拆分开：共享ObservableObject只维护原始元素数据（包含选中状态），每个视图自己管理独立的排序索引列表，拖拽操作仅修改本地排序，不影响共享数组；点击操作修改共享元素的选中状态，实现跨视图高亮同步。

步骤1：修改元素模型，添加高亮状态 #

给MyItem增加isHighlighted属性，用于标记是否高亮：

struct MyItem: Identifiable {
    let id = UUID()
    var name: String
    var isHighlighted = false // 跨视图共享的高亮状态
}

步骤2：重构共享数据源 #

让MyArray只维护原始元素集合，提供查找和更新元素的方法，不再直接被拖拽修改：

class MyArray: ObservableObject {
    @Published var items: [MyItem] = [
        MyItem(name: "Item 1"),
        MyItem(name: "Item 2"),
        MyItem(name: "Item 3")
    ]
    
    // 根据ID查找对应元素
    func item(for id: UUID) -> MyItem? {
        items.first(where: { $0.id == id })
    }
    
    // 更新元素的状态（比如高亮切换）
    func updateItem(_ updatedItem: MyItem) {
        guard let index = items.firstIndex(where: { $0.id == updatedItem.id }) else { return }
        items[index] = updatedItem
    }
}

步骤3：让每个视图维护独立排序 #

每个子视图用@State保存自己的元素ID排序列表，拖拽操作仅修改这个本地列表，不触碰共享数组：

FirstView 实现 #

struct FirstView: View {
    @ObservedObject var myArray: MyArray
    @State private var sortedIds: [UUID] // 本地排序的元素ID列表
    
    init(myArray: MyArray) {
        self.myArray = myArray
        // 初始化时同步原始数组的ID顺序
        _sortedIds = State(initialValue: myArray.items.map(\.id))
    }
    
    var body: some View {
        VStack {
            Text("First View")
            ForEach(sortedIds, id: \.self) { itemId in
                if let item = myArray.item(for: itemId) {
                    Text(item.name)
                        .foregroundColor(item.isHighlighted ? .red : .primary) // 高亮效果
                        .onTapGesture {
                            // 点击切换共享的高亮状态
                            var updatedItem = item
                            updatedItem.isHighlighted.toggle()
                            myArray.updateItem(updatedItem)
                        }
                        .onDrag {
                            let index = sortedIds.firstIndex(of: itemId)!
                            return NSItemProvider(object: "\(index)" as NSString)
                        }
                        .onDrop(of: [.text], delegate: LocalSortDropDelegate(
                            sortedIds: $sortedIds,
                            currentId: itemId
                        ))
                }
            }
        }
        // 监听原始数组的增删，同步本地排序（可选，根据业务需求）
        .onReceive(myArray.$items) { newItems in
            let currentIds = Set(sortedIds)
            sortedIds = newItems.map(\.id).filter(currentIds.contains) 
            + newItems.map(\.id).filter { !currentIds.contains($0) }
        }
    }
}

SecondView 实现 #

和FirstView逻辑完全一致，只是维护自己的sortedIds：

struct SecondView: View {
    @ObservedObject var myArray: MyArray
    @State private var sortedIds: [UUID]
    
    init(myArray: MyArray) {
        self.myArray = myArray
        _sortedIds = State(initialValue: myArray.items.map(\.id))
    }
    
    var body: some View {
        VStack {
            Text("Second View")
            ForEach(sortedIds, id: \.self) { itemId in
                if let item = myArray.item(for: itemId) {
                    Text(item.name)
                        .foregroundColor(item.isHighlighted ? .red : .primary)
                        .onTapGesture {
                            var updatedItem = item
                            updatedItem.isHighlighted.toggle()
                            myArray.updateItem(updatedItem)
                        }
                        .onDrag {
                            let index = sortedIds.firstIndex(of: itemId)!
                            return NSItemProvider(object: "\(index)" as NSString)
                        }
                        .onDrop(of: [.text], delegate: LocalSortDropDelegate(
                            sortedIds: $sortedIds,
                            currentId: itemId
                        ))
                }
            }
        }
        .onReceive(myArray.$items) { newItems in
            let currentIds = Set(sortedIds)
            sortedIds = newItems.map(\.id).filter(currentIds.contains) 
            + newItems.map(\.id).filter { !currentIds.contains($0) }
        }
    }
}

步骤4：实现本地排序的拖拽代理 #

创建通用的DropDelegate，仅修改当前视图的本地排序ID数组：

struct LocalSortDropDelegate: DropDelegate {
    @Binding var sortedIds: [UUID]
    let currentId: UUID
    
    func performDrop(info: DropInfo) -> Bool {
        guard let itemProvider = info.itemProviders(for: [.text]).first else { return false }
        
        itemProvider.loadObject(ofClass: NSString.self) { value, error in
            DispatchQueue.main.async {
                guard let indexStr = value as? String, let sourceIndex = Int(indexStr) else { return }
                moveItem(from: sourceIndex, to: sortedIds.firstIndex(of: currentId)!)
            }
        }
        return true
    }
    
    func dropUpdated(info: DropInfo) -> DropProposal? {
        return DropProposal(operation: .move)
    }
    
    private func moveItem(from sourceIndex: Int, to destinationIndex: Int) {
        guard sourceIndex != destinationIndex else { return }
        let movedItem = sortedIds.remove(at: sourceIndex)
        sortedIds.insert(movedItem, at: destinationIndex)
    }
}

原理说明 #

• 共享状态：MyArray中的items存储元素的核心数据（包括isHighlighted），两个视图通过@ObservedObject监听更新，实现点击高亮同步。
• 本地排序：每个视图的sortedIds独立维护显示顺序，拖拽操作仅修改这个数组，不会影响另一个视图的排序，也不会修改共享的items数组。
• 数据一致性：通过onReceive监听原始数组的增删，同步本地排序ID，保证元素存在性一致。

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