SwiftUI列表多态使用问题：协议约束报错及解决方法

问题场景 #

想将Pig和Frog两个不同类型存入同一数组，用于SwiftUI的List组件，因此让两者遵循继承自Identifiable的Animal协议，但编写代码后出现错误：

Protocol 'Animal' can only be used as a generic constraint because it has Self or associated type requirements

尝试使用带关联类型的协议，仍只能在数组中存储单一类型。

原代码如下：

protocol Animal: Identifiable {
    var id: String { get }
    var name: String { get }
    var count: Int { get }
    var image: String { get }
}

struct Pig: Animal {
    var id: String = UUID().uuidString
    
    var name = "Pig"
    var count = 2
    var image = "🐷"
}

struct Frog: Animal {
    var id: String = UUID().uuidString
    
    var name = "Frog"
    var count = 3
    var image = "🐸"
}

struct ContentView: View {
    var animals: [Animal] = [Pig(), Frog()]

    var body: some View {
        List(animals) { animal in
            Row(animals: animal)
        }
    }
}

错误原因 #

Identifiable协议本身带有关联类型ID，当Animal协议继承Identifiable后，也间接拥有了关联类型要求。Swift中，带有关联类型或Self约束的协议无法直接作为具体类型声明数组（比如[Animal]）——编译器无法确定数组元素的具体类型信息，无法满足关联类型的约束条件，因此抛出该错误。

解决方法 #

方案1：类型擦除（AnyAnimal） #

创建一个类型擦除的结构体，包装Animal协议实例，让它遵循Identifiable和Animal的所有要求，以此统一数组元素类型：

protocol Animal: Identifiable {
    var id: String { get }
    var name: String { get }
    var count: Int { get }
    var image: String { get }
}

struct Pig: Animal {
    var id: String = UUID().uuidString
    var name = "Pig"
    var count = 2
    var image = "🐷"
}

struct Frog: Animal {
    var id: String = UUID().uuidString
    var name = "Frog"
    var count = 3
    var image = "🐸"
}

// 类型擦除包装器
struct AnyAnimal: Animal {
    let id: String
    let name: String
    let count: Int
    let image: String
    
    init<T: Animal>(_ animal: T) {
        self.id = animal.id
        self.name = animal.name
        self.count = animal.count
        self.image = animal.image
    }
}

struct ContentView: View {
    var animals: [AnyAnimal] = [AnyAnimal(Pig()), AnyAnimal(Frog())]

    var body: some View {
        List(animals) { animal in
            VStack {
                Text(animal.name)
                Text("\(animal.count)")
                Text(animal.image)
            }
        }
    }
}

方案2：使用枚举统一类型 #

如果动物类型数量有限，可用枚举统一管理，让枚举遵循Animal和Identifiable协议：

protocol Animal: Identifiable {
    var id: String { get }
    var name: String { get }
    var count: Int { get }
    var image: String { get }
}

enum AnimalType: Animal {
    case pig(count: Int)
    case frog(count: Int)
    
    var id: String { UUID().uuidString }
    
    var name: String {
        switch self {
        case .pig: return "Pig"
        case .frog: return "Frog"
        }
    }
    
    var count: Int {
        switch self {
        case .pig(let count): return count
        case .frog(let count): return count
        }
    }
    
    var image: String {
        switch self {
        case .pig: return "🐷"
        case .frog: return "🐸"
        }
    }
}

struct ContentView: View {
    var animals: [AnimalType] = [.pig(count: 2), .frog(count: 3)]

    var body: some View {
        List(animals) { animal in
            VStack {
                Text(animal.name)
                Text("\(animal.count)")
                Text(animal.image)
            }
        }
    }
}

方案3：改用类继承 #

将Animal改为基类，Pig和Frog继承自它，利用类的引用类型特性直接存入数组：

class Animal: Identifiable {
    var id: String = UUID().uuidString
    var name: String
    var count: Int
    var image: String
    
    init(name: String, count: Int, image: String) {
        self.name = name
        self.count = count
        self.image = image
    }
}

class Pig: Animal {
    init(count: Int = 2) {
        super.init(name: "Pig", count: count, image: "🐷")
    }
}

class Frog: Animal {
    init(count: Int = 3) {
        super.init(name: "Frog", count: count, image: "🐸")
    }
}

struct ContentView: View {
    var animals: [Animal] = [Pig(), Frog()]

    var body: some View {
        List(animals) { animal in
            VStack {
                Text(animal.name)
                Text("\(animal.count)")
                Text(animal.image)
            }
        }
    }
}

内容的提问来源于stack exchange，提问作者Joakim Sjöstedt