Swift JSON解析中基于协议的泛型KeyValue类初始化问题

你的核心问题在于：Swift的协议如果包含Self或关联类型，就无法直接作为具体类型使用；同时，协议本身不能作为泛型参数的具体类型（比如KeyValue<PlainValue>是不合法的，因为PlainValue是协议，不是符合该协议的具体类型）。下面提供两种可行的解决方案，你可以根据需求选择：

方案一：使用类型擦除（Type Erasure）统一包装KeyValue实例 #

这种方式通过一个非泛型的AnyKeyValue类来包装具体的KeyValue<T>实例，这样就能在解析函数中统一处理所有类型的键值对：

1. 定义类型擦除类AnyKeyValue #

class AnyKeyValue {
    let key: NSString
    private let underlyingValue: PlainValue
    
    // 对外暴露统一的PlainValue类型值
    var value: PlainValue {
        return underlyingValue
    }
    
    // 用具体的KeyValue<T>初始化
    init<T: PlainValue>(_ concreteKeyValue: KeyValue<T>) {
        self.key = concreteKeyValue.key
        self.underlyingValue = concreteKeyValue.value
    }
}

2. 修改PlainValue协议，添加转换方法 #

protocol PlainValue {
    func toKeyValue(withKey key: NSString) -> AnyKeyValue
}

3. 为每个符合协议的类型实现转换方法 #

extension NSString: PlainValue {
    func toKeyValue(withKey key: NSString) -> AnyKeyValue {
        return AnyKeyValue(KeyValue(key: key, value: self))
    }
}

extension NSNull: PlainValue {
    func toKeyValue(withKey key: NSString) -> AnyKeyValue {
        return AnyKeyValue(KeyValue(key: key, value: self))
    }
}

extension NSNumber: PlainValue {
    func toKeyValue(withKey key: NSString) -> AnyKeyValue {
        return AnyKeyValue(KeyValue(key: key, value: self))
    }
}

4. 在解析函数中使用 #

func parse(json: [String: Any]) {
    for (stringKey, value) in json {
        let nsKey = stringKey as NSString
        if let plainValue = value as? PlainValue {
            let keyValue = plainValue.toKeyValue(withKey: nsKey)
            // 这里可以统一处理keyValue，比如存入数组或进行后续逻辑
            print("Parsed - Key: \(keyValue.key), Value Type: \(type(of: keyValue.value))")
        }
    }
}

方案二：直接在解析函数中做类型判断（更直观） #

如果你的PlainValue类型固定只有NSString、NSNull、NSNumber三种，也可以直接通过switch或if-let分别处理每种类型，避免额外的类型擦除逻辑：

func parse(json: [String: Any]) {
    for (stringKey, value) in json {
        let nsKey = stringKey as NSString
        
        switch value {
        case let str as NSString:
            let kv = KeyValue(key: nsKey, value: str)
            // 处理NSString类型的KeyValue
            handleKeyValue(kv)
        case let num as NSNumber:
            let kv = KeyValue(key: nsKey, value: num)
            // 处理NSNumber类型的KeyValue
            handleKeyValue(kv)
        case let null as NSNull:
            let kv = KeyValue(key: nsKey, value: null)
            // 处理NSNull类型的KeyValue
            handleKeyValue(kv)
        default:
            // 不符合PlainValue的类型，可选择忽略或抛出错误
            print("Skipping unsupported value type: \(type(of: value))")
        }
    }
}

// 可以定义一个泛型函数统一处理不同类型的KeyValue
func handleKeyValue<T: PlainValue>(_ keyValue: KeyValue<T>) {
    print("Handled - Key: \(keyValue.key), Value: \(keyValue.value)")
}

为什么之前的尝试会失败？ #

• 当你在协议中声明func convert(key: NSString) -> KeyValue<PlainValue>时，PlainValue是协议，不能作为泛型参数的具体类型——Swift要求泛型参数必须是符合约束的具体类型（比如NSString、NSNumber），而不是协议本身。
• 添加关联类型后，协议就带有了Self/关联类型约束，此时无法再用value is PlainValue来做类型检查，因为这类协议只能作为泛型约束使用，不能作为存在类型（existential type）直接判断。

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