SwiftUI中使用协议与TabView报错：'any Target'无法遵循Hashable

SwiftUI的TabView要求绑定的selection类型必须遵循Hashable协议，但你使用的any Target是存在类型，当前Target协议未继承Hashable，且即使协议继承了Hashable，存在类型也无法直接满足哈希与相等性判断的要求——不同结构体实现（Target1/Target2/Target3）作为存在类型时，Swift无法保证它们的哈希逻辑一致。

方案一：改用ID作为选中状态（最简单直接） #

放弃绑定整个Target对象，改用id作为选中状态的类型，避开存在类型的Hashable限制：

protocol Target {
    var id: Int { get }
    var name: String { get }
}

struct Target1: Target {
    var id: Int = 1
    var name: String = "Target1"
}

struct Target2: Target {
    var id: Int = 2
    var name: String = "Target2"
}

struct Target3: Target {
    var id: Int = 3
    var name: String = "Target3"
}

struct ContentView: View {
    
    let targets: [any Target] = [Target1(), Target2(), Target3()]
    @State private var selectedTargetId: Int = 1 // 改为ID类型
    
    var body: some View {
        NavigationStack {
            TabView(selection: $selectedTargetId) {
                ForEach(targets, id: \.id) { target in
                    Text(target.name)
                        .tag(target.id) // 绑定对应目标的ID
                }
            }
            .tabViewStyle(.page(indexDisplayMode: .always))
        }
    }
}

方案二：让协议遵循Hashable并提供默认实现 #

如果必须绑定整个Target对象，可让Target协议继承Hashable，并基于id提供统一的哈希与相等性判断逻辑：

protocol Target: Hashable { // 协议继承Hashable
    var id: Int { get }
    var name: String { get }
}

// 为Target协议提供默认的Hashable实现
extension Target {
    static func == (lhs: Self, rhs: Self) -> Bool {
        lhs.id == rhs.id
    }
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(id)
    }
}

struct Target1: Target {
    var id: Int = 1
    var name: String = "Target1"
}

struct Target2: Target {
    var id: Int = 2
    var name: String = "Target2"
}

struct Target3: Target {
    var id: Int = 3
    var name: String = "Target3"
}

struct ContentView: View {
    
    let targets: [any Target] = [Target1(), Target2(), Target3()]
    @State private var selectedTarget: any Target = Target1()
    
    var body: some View {
        NavigationStack {
            TabView(selection: $selectedTarget) {
                ForEach(targets, id: \.id) { target in
                    Text(target.name)
                        .tag(target as any Target) // 显式标注tag类型为存在类型
                }
            }
            .tabViewStyle(.page(indexDisplayMode: .always))
        }
    }
}

注意：设置tag时需显式转换为any Target，避免Swift推断具体结构体类型导致与selection类型不匹配。

方案三：用枚举封装所有Target类型（类型最安全） #

如果你的Target类型数量固定，可改用枚举封装，枚举天然遵循Hashable：

enum TargetEnum: Hashable {
    case target1, target2, target3
    
    var id: Int {
        switch self {
        case .target1: return 1
        case .target2: return 2
        case .target3: return 3
        }
    }
    
    var name: String {
        switch self {
        case .target1: return "Target1"
        case .target2: return "Target2"
        case .target3: return "Target3"
        }
    }
}

struct ContentView: View {
    
    let targets: [TargetEnum] = [.target1, .target2, .target3]
    @State private var selectedTarget: TargetEnum = .target1
    
    var body: some View {
        NavigationStack {
            TabView(selection: $selectedTarget) {
                ForEach(targets, id: \.self) { target in
                    Text(target.name)
                        .tag(target)
                }
            }
            .tabViewStyle(.page(indexDisplayMode: .always))
        }
    }
}

这种方式完全避免了存在类型的潜在问题，类型安全性最高。

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