SwiftUI中any TestProtocol无法遵循Identifiable/Hashable协议的问题解决方法

这个问题本质是Swift的存在类型（any Protocol）和带关联类型/Self约束的协议之间的天然冲突，我来帮你拆解原因并给出两种实用的解决方案：

问题到底出在哪？ #

你已经让TestProtocol遵循了Identifiable和Hashable，但当你用any TestProtocol作为类型时，编译器不认账，原因有两个：

1. Identifiable的关联类型限制：Identifiable要求有一个具体的ID关联类型（必须是Hashable）。any TestProtocol作为存在类型，它的ID类型信息被擦除了——虽然你在协议里强制id是UUID，但编译器无法确定所有any TestProtocol实例的ID都是统一的UUID类型，因此不认可它符合Identifiable。
2. Hashable的Self约束：Hashable的核心方法（==、hash(into:)）都要求参数是Self类型，也就是和调用者同类型。但any TestProtocol是抽象的存在类型，编译器无法保证数组里的每个实例都是同一个具体类型，所以没办法自动满足Hashable的要求。

解决方案一：用枚举封装具体类型（最直观推荐） #

既然存在类型的抽象性导致了问题，我们可以用枚举把所有实现TestProtocol的具体类型打包起来，让枚举本身遵循Identifiable和Hashable，同时代理协议的方法。这样既保留了多态性，又能满足SwiftUI的要求：

import SwiftUI

// 先把TestProtocol的Identifiable/Hashable约束去掉，交给枚举来处理
protocol TestProtocol {
    var id: UUID { get set }
    var name: String { get set }
    func greeting() -> String
}

struct Person: TestProtocol {
    var id = UUID()
    var name: String
    func greeting() -> String {
        return "my name is \(name) and I'm a human."
    }
}

struct Dog: TestProtocol {
    var id = UUID()
    var name: String
    func greeting() -> String {
        return "my name is \(name) and I'm a dog."
    }
}

// 用枚举封装所有TestProtocol的实现
enum TestEntity: Identifiable, Hashable {
    case person(Person)
    case dog(Dog)
    
    // 遵循Identifiable，直接转发内部实例的id
    var id: UUID {
        switch self {
        case .person(let p): return p.id
        case .dog(let d): return d.id
        }
    }
    
    // 代理TestProtocol的属性和方法，方便外部调用
    var name: String {
        switch self {
        case .person(let p): return p.name
        case .dog(let d): return d.name
        }
    }
    
    func greeting() -> String {
        switch self {
        case .person(let p): return p.greeting()
        case .dog(let d): return d.greeting()
        }
    }
    
    // 因为Person和Dog都是Hashable（自动合成），TestEntity的Hashable可以自动合成
}

struct ContentView: View {
    // 现在用[TestEntity]代替[any TestProtocol]
    var list: [TestEntity] = [.person(Person(name: "p1")), .dog(Dog(name: "d1"))]
    // 初始化要指定具体的TestEntity值
    @State var selected: TestEntity = .person(Person(name: "p1"))
    
    var body: some View {
        VStack {
            Picker(selection: $selected) {
                // 现在ForEach和tag都能正常工作了
                ForEach(list) { item in
                    Text(item.greeting()).tag(item)
                }
            } label: {
                Text("select")
            }
        }
    }
}

解决方案二：类型擦除包装器（保留协议抽象性） #

如果你需要保留TestProtocol的抽象性，不想用枚举把具体类型写死，可以创建一个类型擦除包装器，把any TestProtocol包装成一个具体的、遵循Identifiable和Hashable的类型：

import SwiftUI

protocol TestProtocol: Identifiable, Hashable {
    var id: UUID { get set }
    var name: String { get set }
    func greeting() -> String
}

extension TestProtocol {
    // 给TestProtocol默认实现==和hash方法
    static func == (lhs: Self, rhs: Self) -> Bool {
        return lhs.id == rhs.id
    }
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(id)
    }
}

struct Person: TestProtocol {
    var id = UUID()
    var name: String
    func greeting() -> String {
        return "my name is \(name) and I'm a human."
    }
}

struct Dog: TestProtocol {
    var id = UUID()
    var name: String
    func greeting() -> String {
        return "my name is \(name) and I'm a dog."
    }
}

// 类型擦除包装器：把any TestProtocol转换成具体的类型
struct AnyTestProtocol: Identifiable, Hashable {
    private let base: any TestProtocol
    
    // 转发协议的属性和方法
    var id: UUID { base.id }
    var name: String { base.name }
    
    init(_ base: any TestProtocol) {
        self.base = base
    }
    
    func greeting() -> String {
        base.greeting()
    }
    
    // 实现Hashable的要求
    static func == (lhs: AnyTestProtocol, rhs: AnyTestProtocol) -> Bool {
        lhs.id == rhs.id
    }
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(id)
    }
}

struct ContentView: View {
    // 用[AnyTestProtocol]代替[any TestProtocol]
    var list: [AnyTestProtocol] = [AnyTestProtocol(Person(name: "p1")), AnyTestProtocol(Dog(name: "d1"))]
    @State var selected: AnyTestProtocol = AnyTestProtocol(Person(name: "p1"))
    
    var body: some View {
        VStack {
            Picker(selection: $selected) {
                ForEach(list) { item in
                    Text(item.greeting()).tag(item)
                }
            } label: {
                Text("select")
            }
        }
    }
}

为什么ForEach(list, id: \.id)能临时解决但不合理？ #

这个写法其实是绕过了Identifiable的协议检查，手动指定了id的路径。但你觉得不合理是对的——因为你已经让协议遵循了Identifiable，却还要手动传id，本质是编译器无法识别存在类型的Identifiable一致性，这个写法只是临时补丁，不是根本解决办法。

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