如何在 CodingKeys enum(Codable Protocol)中使用泛型值

Question

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

在结构/类中，我们可以使用泛型值，但如何在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， name： "John"(， __lldb_expr_22.User(id： 2， name： "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类认为可接受的字符串或整数的集合。

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)
}
}