SwiftUI优化：修改单个数据项时避免ForEach渲染全部视图

完全不需要立刻切换到类+ObservedObject的方案，下面我会帮你分析问题根源，然后给出两种基于结构体的优化方案，最后再补充类的方案作为备选。

问题根源 #

你的代码里，PlayersView的@State var players是一个值类型数组。值类型的特性决定了：当你修改数组中的任何元素时，整个数组会被重新创建（相当于新数组替换了旧数组），这会触发PlayersView的body重新计算。默认情况下，SwiftUI会重新生成ForEach里的所有PlayerView实例——哪怕只有一个元素变化，这就是你看到所有子视图都刷新的原因。

解决方案1：给子视图添加Equatable优化（最直接的结构体方案） #

通过让子视图支持Equatable对比，我们可以告诉SwiftUI：只有当绑定的Player真正变化时，才刷新这个子视图。

修改步骤： #

1. 让Player结构体遵循Equatable协议（这样我们才能对比两个Player实例是否相同）：

struct Player: Equatable {
    var name: String
    var score: Int
}

2. 让PlayerView遵循Equatable协议，定义对比规则：

struct PlayerView: View, Equatable {
    // 规则：只要绑定的player实例相同，视图就不需要刷新
    static func == (lhs: PlayerView, rhs: PlayerView) -> Bool {
        lhs.player == rhs.player
    }
    
    @Binding var player: Player
    var body: some View {
        let _ = Self._printChanges()
        return HStack(spacing: 12) {
            Text(player.name).font(.system(size: 20))
            Text("\(player.score)").font(.system(size: 20))
            Button("plus") {
                player.score += 1
            }.font(.system(size: 20))
        }
    }
}

3. 在PlayersView的ForEach中，给PlayerView添加.equatable()修饰符，启用优化：

ForEach($players, id: \.name) { $player in
    PlayerView(player: $player)
        .equatable() // 关键：告诉SwiftUI用Equatable判断是否需要刷新
}

现在再运行代码，修改任意一个Player的score时，只有对应的PlayerView会打印刷新日志，其他子视图完全不会触发刷新。

解决方案2：拆分状态到独立的可识别单元（进阶） #

如果你的子视图渲染成本极高，还可以让Player遵循Identifiable协议，让ForEach更精准地跟踪每个元素：

struct Player: Equatable, Identifiable {
    let id = UUID() // 给每个Player一个唯一标识
    var name: String
    var score: Int
}

然后ForEach可以简化为：

ForEach($players) { $player in
    PlayerView(player: $player)
        .equatable()
}

这种方式下，SwiftUI会通过id更高效地复用视图，配合Equatable优化，局部刷新的效果会更稳定。

备选方案：类+ObservableObject（复杂场景可选） #

如果你的数据模型需要跨多个视图共享状态，或者有更复杂的变化通知需求，可以把Player改成ObservableObject类：

class Player: ObservableObject, Identifiable {
    let id = UUID()
    var name: String
    @Published var score: Int
    
    init(name: String, score: Int) {
        self.name = name
        self.score = score
    }
}

然后修改PlayerView：

struct PlayerView: View {
    @Bindable var player: Player // 用Bindable包装ObservableObject，获取绑定能力
    var body: some View {
        let _ = Self._printChanges()
        return HStack(spacing: 12) {
            Text(player.name).font(.system(size: 20))
            Text("\(player.score)").font(.system(size: 20))
            Button("plus") {
                player.score += 1
            }.font(.system(size: 20))
        }
    }
}

这种方式下，只有被修改的Player实例会发送objectWillChange通知，对应的子视图才会刷新——甚至父视图都不会因为单个Player的变化而重新计算（因为数组存储的是引用类型，修改元素属性不会改变数组本身的引用）。

总结 #

• 如果你想继续使用结构体，方案1的Equatable优化完全可以满足你的需求，实现只有修改的子视图刷新。
• 只有当你需要更复杂的状态管理时，再考虑使用类+ObservableObject的方案。

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