json - 在 Swift 中安全地访问具有任意结构的键和值的 JSON 字典？

Question

我正在尝试从没有定义结构的 JSON 对象中读取键和值。 JSON 看起来类似于:

{
    "content":"me,menu_cta,page",
    "me": {
        "email": "person@example.com",
        "first_name": "Jordan"
    },
    "menu_cta": {
        "menu_text": "Tap here"
    },
    "page": {
        "how_it_works": "Make sure you're tapping the right spots.'",
        "page_icon": "https://www.example.com/button.png",
        "terms": "Terms and Conditions"
    }
}

我认为我不能使用 Codeable，因为我在编译时不确定字典中的键是什么，而且我也不确定这些值是字符串还是字典。读取的 JSON 中的键是基于用户交互的动态。

我可以从设置 Dictionary 对象开始:

let json = try? JSONSerialization.jsonObject(with: data, options: [])
  if let dictionary = json as? [String: Any] {
    self.prefetchDictionary = content
  }
}

但是当尝试读取任何数据时，理想情况下我想请求 page.how_it_works 但我认为执行此操作的最佳方法如下所示:

if let pageGenericDictionary = prefetchDictionary?["page"] {
  if let pageDictionary = prefetchDictionary as? [String:String] {
    headerText.text = pageDictionary["how_it_works"]
  }
}

这是最简单的方法吗？有没有什么方法可以编写一个简单的函数，可以使用 page.how_it_works 或 me.email 等定义轻松遍历？

我试图避免包含第三方库来实现此目的。

Answer 1

首先，它有多任意？上面的内容表明这正是 [String: [String: String]]，它是 Decodable，并且您应该使用 JSONDecoder 而不是 JSONSerialization(通常应该避免 JSONSerialization):

let dict = try JSONDecoder().decode([String: [String: String]].self, from: json)

如果实际的结构是任意的，那么我建议使用任意的 JSON 解码器。此处的简化版本( full version ):

enum JSON: Codable {
    struct Key: CodingKey, Hashable {
        let stringValue: String
        init(_ string: String) { self.stringValue = string }
        init?(stringValue: String) { self.init(stringValue) }
        var intValue: Int? { return nil }
        init?(intValue: Int) { return nil }
    }

    case string(String)
    case number(Double) // FIXME: Split Int and Double
    case object([Key: JSON])
    case array([JSON])
    case bool(Bool)
    case null

    init(from decoder: Decoder) throws {
        if let string = try? decoder.singleValueContainer().decode(String.self) { self = .string(string) }
        else if let number = try? decoder.singleValueContainer().decode(Double.self) { self = .number(number) }
        else if let object = try? decoder.container(keyedBy: Key.self) {
            var result: [Key: JSON] = [:]
            for key in object.allKeys {
                result[key] = (try? object.decode(JSON.self, forKey: key)) ?? .null
            }
            self = .object(result)
        }
        else if var array = try? decoder.unkeyedContainer() {
            var result: [JSON] = []
            for _ in 0..<(array.count ?? 0) {
                result.append(try array.decode(JSON.self))
            }
            self = .array(result)
        }
        else if let bool = try? decoder.singleValueContainer().decode(Bool.self) { self = .bool(bool) }
        else if let isNull = try? decoder.singleValueContainer().decodeNil(), isNull { self = .null }
        else { throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: [],
                                                                       debugDescription: "Unknown JSON type")) }
    }

    func encode(to encoder: Encoder) throws {
        switch self {
        case .string(let string):
            var container = encoder.singleValueContainer()
            try container.encode(string)
        case .number(let number):
            var container = encoder.singleValueContainer()
            try container.encode(number)
        case .bool(let bool):
            var container = encoder.singleValueContainer()
            try container.encode(bool)
        case .object(let object):
            var container = encoder.container(keyedBy: Key.self)
            for (key, value) in object {
                try container.encode(value, forKey: key)
            }
        case .array(let array):
            var container = encoder.unkeyedContainer()
            for value in array {
                try container.encode(value)
            }
        case .null:
            var container = encoder.singleValueContainer()
            try container.encodeNil()
        }
    }

    subscript(key: String) -> JSON? {
        guard let jsonKey = Key(stringValue: key),
            case .object(let object) = self,
            let value = object[jsonKey]
            else { return nil }
        return value
    }

    var stringValue: String? {
        switch self {
        case .string(let string): return string
        default: return nil
        }
    }

    var doubleValue: Double? {
        switch self {
        case .number(let number): return number
        default: return nil
        }
    }

    var intValue: Int? {
        switch self {
        case .number(let number): return Int(number)
        default: return nil
        }
    }

    subscript(index: Int) -> JSON? {
        switch self {
        case .array(let array): return array[index]
        default: return nil
        }
    }

    var boolValue: Bool? {
        switch self {
        case .bool(let bool): return bool
        default: return nil
        }
    }
}

这样，你就得到了语法:

let result = try JSONDecoder().decode(JSON.self, from: json)
let str: String? = result["page"]?["how_it_works"]?.stringValue

如果您确实想要点式语法，可以使用 @dynamicMemberLookup 来实现:

@dynamicMemberLookup
enum JSON: Codable {

    subscript(dynamicMember member: String) -> JSON {
        return self[member] ?? .null
    }

    ... the rest is the same ...

这会给你语法:

let x = result.page.how_it_works.stringValue