如何快速解析这种 JSON 格式

Question

我有这种 JSON 格式：

{
  "version":"7.0.19",
  "fields": ["ID","pm","age","pm_0","pm_1","pm_2","pm_3","pm_4","pm_5","pm_6","conf","pm1","pm_10","p1","p2","p3","p4","p5","p6","Humidity","Temperature","Pressure","Elevation","Type","Label","Lat","Lon","Icon","isOwner","Flags","Voc","Ozone1","Adc","CH"],
  "data":[[20,0.0,1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,97,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,null,null,null,1413,0,"Oakdale",40.603077,-111.83612,0,0,0,null,null,0.01,1]],
  "count":11880
}

但我不知道如何使用 Codable 协议来解析 json 响应。

这将是我想要的模型。

struct Point: Codable {
    let pm2: String?
    let latitude, longitude: Double?
    let temp: String?
    let iD: String?
    enum CodingKeys: String, CodingKey {
        case pm2 = "pm", temp = "Temperature", iD = "ID", latitude = "Lat", longitude = "Lon"
    }
}

这是 json 的 URL

https://webbfoot.com/dataa.json

Answer 1

你可以使用Codable来解析这个：

struct Response: Decodable {

   let version: String
   let fields: [String]
   let data: [[QuantumValue?]]
   let count: Int

}
enter code here

enum QuantumValue: Decodable {

case float(Float), string(String)

init(from decoder: Decoder) throws {
    if let int = try? decoder.singleValueContainer().decode(Float.self) {
        self = .float(float)
        return
    }

    if let string = try? decoder.singleValueContainer().decode(String.self) {
        self = .string(string)
        return
    }

    throw QuantumError.missingValue
}

enum QuantumError:Error {
    case missingValue
}
}

QuantumValue 将处理 Float 和 String 和 ? 将处理 null 部分。

Answer 2

这个比较棘手，需要手动解码。原则是定义您希望解码的字段和对象的属性之间的映射，然后根据属性的类型（String、Double 等...），尝试解码数据.

第二，既然你有一个点数组，你需要某种容器对象来保存这个数组，例如：

struct Points {
    var data: [Point] = []
}

首先，您的某些模型属性与数据中的类型不匹配，例如iD 是 String，但数据有 Int。为简单起见，我将重新定义您的模型以匹配数据

struct Point {
    var pm2: Int? = nil
    var latitude: Double? = nil
    var longitude: Double? = nil
    var temp: Int? = nil
    var iD: Int? = nil
}

现在，为父容器Points编写手动解码器：

extension Points: Decodable {   
    static let mapping: [String: PartialKeyPath<Point>] = [
        "pm":          \Point.pm2,
        "Lat":         \Point.latitude,
        "Lon":         \Point.longitude,
        "Temperature": \Point.temp,
        "ID":          \Point.iD
    ]

    enum CodingKeys: CodingKey { case fields, data }
    private struct Dummy: Decodable {} // see below why

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

        let fields = try container.decode([String].self, forKey: .fields)
        var data = try container.nestedUnkeyedContainer(forKey: .data)

        while !data.isAtEnd {
            var row = try data.nestedUnkeyedContainer()

            var point = Point()          
            for field in fields {

                let keyPath = Points.mapping[field]
                switch keyPath {
                case let kp as WritableKeyPath<Point, String?>:
                    point[keyPath: kp] = try row.decodeIfPresent(String.self)
                case let kp as WritableKeyPath<Point, Int?>:
                    point[keyPath: kp] = try row.decodeIfPresent(Int.self)
                case let kp as WritableKeyPath<Point, Double?>:
                    point[keyPath: kp] = try row.decodeIfPresent(Double.self)
                default:
                    // this is a hack to skip this value
                    let _ = try? row.decode(Dummy.self)
                }
            }
            self.data.append(point)
        }
    }
}

一旦你有了它，你就可以像这样解码 JSON：

let points = try JSONDecoder().decode(Points.self, from: jsonData)
let firstPoint = points.data[0]