时间戳

首页 > 解决方案 > 在 Swift 中安全地访问具有任意键和值结构的 JSON 字典？

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

问题描述

我正在尝试从没有定义结构的 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_worksor之类的定义轻松遍历me.email？

我试图避免包含一个 3rd 方库来实现这一点。

标签： jsonswift

解决方案

首先，它有多随意？以上表明这正是[String: [String: String]]，即Decodable，您应该使用JSONDecoder而不是JSONSerialization（通常应该避免JSONSerialization）：

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

如果实际结构是任意的，那么我建议使用任意 JSON 解码器。这里的简化版（完整版）：

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

推荐阅读