Swift中如何无需新增枚举即可切换处理多个关联枚举？

当然有可行方案，下面提供几种实用的实现思路，不需要新增第三个合并枚举：

方法1：用通用协议统一枚举类型 #

先给两个现有枚举定义一个共同的协议，让它们都遵循这个协议，这样函数就可以接收该协议类型的参数，再内部区分具体枚举处理。

示例代码 #

// 基础协议与类定义（你的原有代码）
protocol MasterProtocol {}
protocol ChildProtocol1: MasterProtocol {}
protocol ChildProtocol2: MasterProtocol {}

class ClassA: ChildProtocol1 {}
class ClassB: ChildProtocol1 {}
class ClassC: ChildProtocol2 {}
class ClassD: ChildProtocol2 {}

enum Protocol1Classes {
    case classA, classB
}

enum Protocol2Classes {
    case classC, classD
}

// 定义通用协议，让两个枚举遵循
protocol ClassEnumType {
    // 可选：如果需要生成对应类的实例，可添加此方法
    func createInstance() -> MasterProtocol
}

// 扩展Protocol1Classes遵循协议
extension Protocol1Classes: ClassEnumType {
    func createInstance() -> MasterProtocol {
        switch self {
        case .classA: return ClassA()
        case .classB: return ClassB()
        }
    }
}

// 扩展Protocol2Classes遵循协议
extension Protocol2Classes: ClassEnumType {
    func createInstance() -> MasterProtocol {
        switch self {
        case .classC: return ClassC()
        case .classD: return ClassD()
        }
    }
}

// 处理函数
func processClassEnum(_ enumValue: ClassEnumType) {
    // 先区分是哪个枚举类型
    switch enumValue {
    case let p1Enum as Protocol1Classes:
        // 处理Protocol1Classes的具体case
        switch p1Enum {
        case .classA:
            print("执行ClassA对应的业务逻辑")
        case .classB:
            print("执行ClassB对应的业务逻辑")
        }
    case let p2Enum as Protocol2Classes:
        // 处理Protocol2Classes的具体case
        switch p2Enum {
        case .classC:
            print("执行ClassC对应的业务逻辑")
        case .classD:
            print("执行ClassD对应的业务逻辑")
        }
    default:
        print("不支持的枚举类型")
    }
}

// 调用示例
processClassEnum(Protocol1Classes.classA)
processClassEnum(Protocol2Classes.classD)

方法2：直接用Any参数（轻量方案） #

如果不想新增协议，也可以让函数接收Any类型参数，通过类型判断区分两个枚举：

示例代码 #

// 沿用你的原有协议、类、枚举定义

func processAnyEnum(_ value: Any) {
    switch value {
    case let p1Enum as Protocol1Classes:
        switch p1Enum {
        case .classA: /* 自定义逻辑 */
        case .classB: /* 自定义逻辑 */
        }
    case let p2Enum as Protocol2Classes:
        switch p2Enum {
        case .classC: /* 自定义逻辑 */
        case .classD: /* 自定义逻辑 */
        }
    default:
        fatalError("参数必须是Protocol1Classes或Protocol2Enum类型")
    }
}

方法3：结合实例处理（如果逻辑围绕类实例展开） #

如果你的业务逻辑更多是针对遵循子协议的类实例，也可以在函数里先通过枚举生成实例，再判断实例的协议/类型：

// 沿用方法1中的ClassEnumType协议及扩展

func processInstance(from enumValue: ClassEnumType) {
    let instance = enumValue.createInstance()
    
    switch instance {
    case is ChildProtocol1:
        print("处理ChildProtocol1类型实例的通用逻辑")
        // 如需区分具体类
        if instance is ClassA {
            print("针对ClassA的特殊逻辑")
        }
    case is ChildProtocol2:
        print("处理ChildProtocol2类型实例的通用逻辑")
        if instance is ClassD {
            print("针对ClassD的特殊逻辑")
        }
    default:
        break
    }
}

这些方案都不需要合并原有枚举，既能保留两个枚举的独立性，又能实现统一的函数处理逻辑。

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