如何在CodingKeys枚举（可编码协议）中使用通用值

Question

这个问题已经在这里有了答案：

• Swift 4可解码，直到解码时间 3 才知道密钥
• 如何在可编码类型 10中 使用Any

编译器抱怨：“枚举大小写的原始值必须是文字”

在struct / class中，我们可以使用泛型值，但是如何在enum使用泛型。

下面是我要进行一般结构的服务器响应

{
  "status": true,
  "message": "message",
  "error" : "error if any"
  "any key" : "Any kind of data"
}

在上面的示例中，“任何键”部分都很棘手。 对于不同的服务呼叫，“任何键”将有所不同。

对于用户城市列表：

{
  "status": true,
  "message": "message",
  "error" : ""
  "cities" : "city list"
}

对于用户状态列表：

{
  "status": true,
  "message": "message",
  "error" : ""
  "states" : "state list"
}

对于用户帖子：

{
  "status": true,
  "message": "message",
  "error" : ""
  "posts" : "list of posts"
}

您可以看到每个服务调用都有相同的“状态”，“消息”和“错误” 键，数据具有不同的键“城市”，“状态”，“帖子”等。

因此，我想创建一个通用结构，将所有这些都包括在内。

我按照以下方式进行，但停留在不同的键上。

struct Response<T>: Codable  {


let message : String? // common in every service call
let status : Bool? // common in every service call
let errors: String? // common in every service call
let data : T? // it will be different for every call

enum CodingKeys: String, CodingKey {

    case message = "message"
    case status = "status"
    case data = <key>    //Here what to use?
    case errors = "errors"
}

init(from decoder: Decoder) throws {
    let values = try decoder.container(keyedBy: CodingKeys.self)

    message = try values.decodeIfPresent(String.self, forKey: .message)
    status = try values.decodeIfPresent(Bool.self, forKey: .status)
    errors = try values.decodeIfPresent(String.self, forKey: .errors)
    data = try T(from: decoder)
}

}

我可能要做什么？

如果是，该如何实现？

任何帮助将不胜感激！！

尝试时出现以下错误。

1. 枚举大小写的原始值必须是文字

2. 非标称类型“ T”不支持显式初始化

Answer 1

一种选择是（实际上不起作用，请参见下面的评论）：

struct Response<T>: Codable  {
    let message : String? // if these exist in every call do they have to be optional?
    let status : Bool? 
    let errors: String?
    let data: T
}

struct Users: Codable {
    let users: [User]
}

struct Cities: Codable {
    let cities: [City]
}

let response = JSONDecoder().decode(Response<Users>.self, from: data)

几乎相同，但没有泛型：

class Response: Codable  {
    let message : String? // if these exist in every call do they have to be optional?
    let status : Bool? 
    let errors: String?
}

class UserResponse: Response, Codable {
    let users: [User]
}

class CitiesResponse: Response, Codable {
    let cities: [City]
}

您的主要问题是Codable需要知道要解码和映射到的类型，因此您需要使用泛型（ Response<Users> ）指定类型，或者使用继承来创建特定类型。

更新：

泛型选项不起作用，因为Codable仍然需要知道密钥，因此您最终要进行大量的密钥检查，并且知道什么密钥与哪种类型匹配，从而使其毫无意义。

我确实设法解码了一个示例用户，该示例用户应该可以在城市和其他类型中重用，但似乎有些麻烦。

import PlaygroundSupport

let userJsonData = """
{
"status": true,
"message": "message",
"error" : "error if any",
"users" : [{
    "id": 1,
    "name": "John"
}, {
    "id": 2,
    "name": "Steve"
}]
}
""".data(using: .utf8)!

class Response: Codable {
    let error: String
    let status: Bool
    let message: String
}

struct User: Codable {
    let id: Int
    let name: String
}

class Users: Response {
    var users: [User]

    enum CodingKeys: String, CodingKey {
        case users
    }

    required init(from decoder: Decoder) throws {
        let values = try decoder.container(keyedBy: CodingKeys.self)
        users = try values.decode([User].self, forKey: .users)
        try super.init(from: decoder)
    }
}

do {
     let response = try JSONDecoder().decode(Users.self, from: userJsonData)
    print(response.users)
} catch {
    print(error)
}

输出：

[__lldb_expr_22.User（id：1，名称：“ John”），__lldb_expr_22.User（id：2，名称：“ Steve”）]

Answer 2

更新资料

由于enum需要文字：

protocol ResponseData: Decodable {
    static var attributeName: String { get }
}

struct Response<T>: Decodable  where T: ResponseData {
    let message : String
    let status : Bool
    let errors: String
    let data: T

编码键只是CodingKey类认为可接受的字符串或整数的CodingKey 。

    struct MyCodingKeys: CodingKey {
        var stringValue: String
        var intValue: Int?

        init?(intValue: Int) {
            return nil
        }

        init?(stringValue: String) {
            if let _ = DefaultCodingKeys.init(rawValue: stringValue){
                // OK
            } else if stringValue == T.attributeName {
                // OK
            } else {
                // NOT OK
                return nil
            }

            self.stringValue = stringValue
            self.intValue = nil
        }

        enum DefaultCodingKeys: String, CodingKey {
            case message = "message"
            case status = "status"
            case errors = "errors"
        }

由于其结构而不是枚举，因此必须手动创建它们。

        static var data: MyCodingKeys {
            return MyCodingKeys(stringValue: T.attributeName)!
        }
        static var message: MyCodingKeys {
            return MyCodingKeys(stringValue: "message")!
        }
        static var errors: MyCodingKeys {
            return MyCodingKeys(stringValue: "errors")!
        }
        static var status: MyCodingKeys {
            return MyCodingKeys(stringValue: "status")!
        }
    }

这是必需的，因为即使MyCodingKeys被命名为CodingKeys ， Swift也不会使用它，因为Swift对此需要enums 。

    init(from decoder: Decoder) throws {
        let values = try decoder.container(keyedBy: MyCodingKeys.self)

        message = try values.decode(String.self, forKey: .message)
        status = try values.decode(Bool.self, forKey: .status)
        errors = try values.decode(String.self, forKey: .errors)
        data = try values.decode(T.self, forKey: .data)
    }
}