Swift 4中如何使用JSONEncoder编码[String:Encodable]类型字典？

你遇到的这个错误核心原因是：Encodable是一个协议，而非具体类型，JSONEncoder需要明确知晓每个待编码类型的具体实现逻辑，但[String: Encodable]字典的Value是协议类型，编码器无法确定如何处理每一个不同的Encodable实现。

下面给你几种可行的解决方法：

方法一：自定义Encodable包装器（推荐） #

我们可以创建一个通用的包装器类型，把任意Encodable值包裹起来，让这个包装器实现Encodable协议，内部将编码逻辑委托给被包装的值：

struct EncodableWrapper: Encodable {
    let value: Encodable
    
    func encode(to encoder: Encoder) throws {
        try value.encode(to: encoder)
    }
}

接着修改你的Request协议与实现，将params的类型调整为[String: EncodableWrapper]：

protocol Request {
    var params: [String: EncodableWrapper] { get set }
    func encode<T>(_ value: T) throws -> Data where T : Encodable
}

extension Request {
    func encode<T>(_ value: T) throws -> Data where T : Encodable {
        return try JSONEncoder().encode(value)
    }
    var body: Data? {
        if let encoded = try? self.encode(self.params) {
            return encoded
        }
        return nil
    }
}

struct BaseRequest: Request {
    var params: [String : EncodableWrapper]
}

// 使用时将值包装后传入
let dict = ["name": EncodableWrapper(value: "abcde")]
let req = BaseRequest(params: dict)
let body = req.body

这样编码器就能通过包装器正确调用每个值的encode方法了。

方法二：使用具体结构体替代字典（最类型安全） #

如果你的请求参数结构是固定的，最佳方式是定义一个对应参数的结构体，让它遵守Encodable协议，这种方式不仅类型安全，还能彻底避免协议类型带来的问题：

protocol Request {
    associatedtype Params: Encodable
    var params: Params { get set }
    func encode<T>(_ value: T) throws -> Data where T : Encodable
}

extension Request {
    func encode<T>(_ value: T) throws -> Data where T : Encodable {
        return try JSONEncoder().encode(value)
    }
    var body: Data? {
        if let encoded = try? self.encode(self.params) {
            return encoded
        }
        return nil
    }
}

// 定义具体的参数结构体
struct UserParams: Encodable {
    let name: String
}

struct BaseRequest<Params: Encodable>: Request {
    var params: Params
}

// 使用示例
let params = UserParams(name: "abcde")
let req = BaseRequest(params: params)
let body = req.body

这种方式能在编译阶段就检查参数的正确性，不会出现类型不匹配的问题，是Swift中处理编码场景的最佳实践。

方法三：使用JSONSerialization（不推荐，类型不安全） #

如果一定要保留字典形式，也可以先将字典转成JSON对象再转成Data，但这种方式会失去类型安全，还需处理Any类型的转换：

extension Request {
    var body: Data? {
        // 将Encodable值转成JSON支持的Any类型
        func convertToAny(_ encodable: Encodable) -> Any? {
            do {
                let data = try JSONEncoder().encode(encodable)
                return try JSONSerialization.jsonObject(with: data)
            } catch {
                return nil
            }
        }
        
        let anyDict = params.compactMapValues { convertToAny($0) }
        guard JSONSerialization.isValidJSONObject(anyDict) else {
            return nil
        }
        return try? JSONSerialization.data(withJSONObject: anyDict)
    }
}

这种方法虽能工作，但会引入额外的转换步骤，若Encodable值无法转成JSON支持的类型（比如自定义复杂类型），还会丢失数据，仅建议在特殊场景下使用。

内容的提问来源于stack exchange，提问作者鸡肉味嘎嘣脆