JSON-Kodierung mit backslashes

@ericd Kommentare hat mir geholfen, das Problem zu lösen. Ich akzeptierte seine Antwort für diese Frage. Da bin ich mit Alamofire für den asynchronen Betrieb, und SwiftyJSON, den ich nicht nutzen konnte seinem code. Hier ist der code mit Alamofire und SwiftyJSON.

Alamofire.request(.POST, url, parameters: param, encoding: .JSON)
   .responseJSON { (req, res, json, error) in
    if(error != nil) {
        NSLog("Error: \(error)")
        failure(res, json, error)
    }
    else {

        var jsond = JSON(json!)
        var data = jsond["d"].stringValue.dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)
        jsond = JSON(data: data!)

Hier ist ein weiterer Ansatz für Swift 4 - Mit kodierbar

Diese wurde von json, die ich erhielt:

{
    "error_code": 0,
    "result": {
        "responseData": "{\"emeter\":{\"get_realtime\":{\"voltage_mv\":237846,\"current_ma\":81,\"power_mw\":7428,\"total_wh\":1920,\"err_code\":0}}}"
    }
} 

Den JSON-Teil mit backslashes ist gleich diesem:

{
    "emeter": {
        "get_realtime": {
            "voltage_mv": 237846,
            "current_ma": 81,
            "power_mw": 7428,
            "total_wh":19201,
            "err_code":0
        }
    }
}

- Und dies war der code, den ich verwendet:

import Foundation

class RealtimeEnergy: Codable {
    let errorCode: Int
    let result: ResultRealtimeEnergy?
    let msg: String?

    enum CodingKeys: String, CodingKey {
        case errorCode = "error_code"
        case result, msg
    }

    init(errorCode: Int, result: ResultRealtimeEnergy?, msg: String?) {
        self.errorCode = errorCode
        self.result = result
        self.msg = msg
    }
}

class ResultRealtimeEnergy: Codable {

    let responseData: String
    var emeter: Emeter

    enum CodingKeys: String, CodingKey {
        case responseData
    }

    required init(from decoder: Decoder) throws {

        let container = try decoder.container(keyedBy: CodingKeys.self)
        responseData = try container.decode(String.self, forKey: .responseData)
        let dataString = try container.decode(String.self, forKey: .responseData)
        emeter = try JSONDecoder().decode(Emeter.self, from: Data(dataString.utf8))
    }
}



class Emeter: Codable {
    let emeter: EmeterClass

    init(emeter: EmeterClass) {
        self.emeter = emeter
    }
}

class EmeterClass: Codable {
    let getRealtime: GetRealtime

    enum CodingKeys: String, CodingKey {
        case getRealtime = "get_realtime"
    }

    init(getRealtime: GetRealtime) {
        self.getRealtime = getRealtime
    }
}

class GetRealtime: Codable {
    let voltageMv, currentMa, powerMw, totalWh: Int
    let errCode: Int

    enum CodingKeys: String, CodingKey {
        case voltageMv = "voltage_mv"
        case currentMa = "current_ma"
        case powerMw = "power_mw"
        case totalWh = "total_wh"
        case errCode = "err_code"
    }

    init(voltageMv: Int, currentMa: Int, powerMw: Int, totalWh: Int, errCode: Int) {
        self.voltageMv = voltageMv
        self.currentMa = currentMa
        self.powerMw = powerMw
        self.totalWh = totalWh
        self.errCode = errCode
    }
}

- Und das ist der trick:

emeter = try JSONDecoder().decode(Emeter.self, from: Data(dataString.utf8))

Ich verbrachte viel zu lange, um herauszufinden, das gleiche Problem. Hier ist, wie ich es gelöst.

Ich habe ein Netzwerk-manager, wenn Sie aufgerufen wird, gibt eine Antwort zurück von [Alle]?

Ich eine Schleife durch jeden Datensatz umwandeln in JSON, aber das nicht erkennen der inhärenten dictionary-Struktur in diesem Fall.

So, ich Reiß den rawString und verwenden Sie dann analysieren. Dieser erkennt das Wörterbuch.

Von dort aus sollten Sie in der Lage sein, es zu benutzen, wie Sie möchte. In meinem Beispiel gebe ich die Daten in ein Daten-Modell (MyApi),

networkManager .requestResource(withUrl: urlPath, andParams: params, 
successHandler: { (response: [Any]?) in

            if let rawResponse = response {

                let mutableArray = NSMutableArray()

                for item in rawResponse {

                    let jsonData = JSON(item)
                    guard let rawString = jsonData.rawString() else {
                        return
                    }

                    let parsedData = JSON.parse(rawString)

                let typedResponse = MyApi(json: parsedData)
                    mutableArray.add(typedResponse)
                }

                let array = mutableArray.copy() as! [MyApi]
                //do something with array

            } else {
                let error = NSError .init(domain: "MyApi", code: 100, userInfo: nil)
                //log error
            }

        }, failureHandler: { (response: [Any]?) in

            let error = NSError .init(domain: "MyApi", code: 101, userInfo: nil)
            //log error
        })