JSON in Swift richtig analysieren 3

Eine große Änderung, die mit Xcode 8 Beta 6 für Swift 3 stattfand, war, dass die ID jetzt als Any und nicht als AnyObject importiert wird.

Dies bedeutet, dass parsedData als Wörterbuch der wahrscheinlichsten mit dem Typ [Any:Any] zurückgegeben wird. Ohne einen Debugger konnte ich Ihnen nicht genau sagen, was Ihre Besetzung in NSDictionary tun wird, aber der Fehler, den Sie sehen, ist, dass dict!["currently"]! den Typ Any hat

Wie lösen Sie das? Ich gehe davon aus, wie Sie darauf verwiesen haben, dass dict!["currently"]! ein Wörterbuch ist, und Sie haben viele Optionen:

Zuerst könnte man so etwas machen: 

let currentConditionsDictionary: [String: AnyObject] = dict!["currently"]! as! [String: AnyObject]  

Dadurch erhalten Sie ein Wörterbuchobjekt, das Sie anschließend nach Werten abfragen können. So können Sie Ihre Temperatur wie folgt ermitteln: 

let currentTemperatureF = currentConditionsDictionary["temperature"] as! Double

Oder wenn Sie es vorziehen, können Sie es in einer Reihe machen: 

let currentTemperatureF = (dict!["currently"]! as! [String: AnyObject])["temperature"]! as! Double

Hoffentlich hilft das, ich fürchte, ich hatte keine Zeit, eine Beispiel-App zu schreiben, um sie zu testen.

Eine letzte Anmerkung: Am einfachsten ist es, wenn Sie die JSON-Nutzlast gleich zu Beginn in [String: AnyObject] ablegen.

let parsedData = try JSONSerialization.jsonObject(with: data as Data, options: .allowFragments) as! Dictionary<String, AnyObject>

let str = "{\"names\": [\"Bob\", \"Tim\", \"Tina\"]}"

let data = str.data(using: String.Encoding.utf8, allowLossyConversion: false)!

do {
    let json = try JSONSerialization.jsonObject(with: data, options: []) as! [String: AnyObject]
    if let names = json["names"] as? [String] 
{
        print(names)
}
} catch let error as NSError {
    print("Failed to load: \(error.localizedDescription)")
}

Ich habe quicktype genau für diesen Zweck gebaut. Fügen Sie einfach Ihre Beispiel-JSON ein und quicktype generiert diese Typhierarchie für Ihre API-Daten:

struct Forecast {
    let hourly: Hourly
    let daily: Daily
    let currently: Currently
    let flags: Flags
    let longitude: Double
    let latitude: Double
    let offset: Int
    let timezone: String
}

struct Hourly {
    let icon: String
    let data: [Currently]
    let summary: String
}

struct Daily {
    let icon: String
    let data: [Datum]
    let summary: String
}

struct Datum {
    let precipIntensityMax: Double
    let apparentTemperatureMinTime: Int
    let apparentTemperatureLowTime: Int
    let apparentTemperatureHighTime: Int
    let apparentTemperatureHigh: Double
    let apparentTemperatureLow: Double
    let apparentTemperatureMaxTime: Int
    let apparentTemperatureMax: Double
    let apparentTemperatureMin: Double
    let icon: String
    let dewPoint: Double
    let cloudCover: Double
    let humidity: Double
    let ozone: Double
    let moonPhase: Double
    let precipIntensity: Double
    let temperatureHigh: Double
    let pressure: Double
    let precipProbability: Double
    let precipIntensityMaxTime: Int
    let precipType: String?
    let sunriseTime: Int
    let summary: String
    let sunsetTime: Int
    let temperatureMax: Double
    let time: Int
    let temperatureLow: Double
    let temperatureHighTime: Int
    let temperatureLowTime: Int
    let temperatureMin: Double
    let temperatureMaxTime: Int
    let temperatureMinTime: Int
    let uvIndexTime: Int
    let windGust: Double
    let uvIndex: Int
    let windBearing: Int
    let windGustTime: Int
    let windSpeed: Double
}

struct Currently {
    let precipProbability: Double
    let humidity: Double
    let cloudCover: Double
    let apparentTemperature: Double
    let dewPoint: Double
    let ozone: Double
    let icon: String
    let precipIntensity: Double
    let temperature: Double
    let pressure: Double
    let precipType: String?
    let summary: String
    let uvIndex: Int
    let windGust: Double
    let time: Int
    let windBearing: Int
    let windSpeed: Double
}

struct Flags {
    let sources: [String]
    let isdStations: [String]
    let units: String
}

Es generiert auch einen Abhängigkeit-Marshalling-Code, um den Rückgabewert von JSONSerialization.jsonObject in eine Forecast zu überführen, einschließlich eines Convenience-Konstruktors, der einen JSON-String verwendet, damit Sie einen stark typisierten Forecast-Wert schnell analysieren und auf seine Felder zugreifen können:

let forecast = Forecast.from(json: jsonString)!
print(forecast.daily.data[0].windGustTime)

Sie können Quicktype von npm mit npm i -g quicktype installieren oder verwenden Sie die Web-Benutzeroberfläche , um den vollständig generierten Code in Ihren Spielplatz einzufügen.

Aktualisiert anschließend die isConnectToNetwork-Funktion, dank diesem Beitrag Mit Swift auf Internetverbindung prüfen

ich habe eine extra Methode dafür geschrieben: 

import SystemConfiguration

func loadingJSON(_ link:String, postString:String, completionHandler: @escaping (_ JSONObject: AnyObject) -> ()) {
    if(isConnectedToNetwork() == false){
       completionHandler("-1" as AnyObject)
       return
    }

    let request = NSMutableURLRequest(url: URL(string: link)!)
    request.httpMethod = "POST"
    request.httpBody = postString.data(using: String.Encoding.utf8)

    let task = URLSession.shared.dataTask(with: request as URLRequest) { data, response, error in
    guard error == nil && data != nil else {                                                          // check for fundamental networking error
        print("error=\(error)")
        return
        }

    if let httpStatus = response as? HTTPURLResponse , httpStatus.statusCode != 200 {           // check for http errors
        print("statusCode should be 200, but is \(httpStatus.statusCode)")
        print("response = \(response)")
    }


    //JSON successfull
    do {

        let parseJSON = try JSONSerialization.jsonObject(with: data!, options: .allowFragments)

        DispatchQueue.main.async(execute: {
            completionHandler(parseJSON as AnyObject)
        });


    } catch let error as NSError {
        print("Failed to load: \(error.localizedDescription)")

    }
  }
  task.resume()
}


func isConnectedToNetwork() -> Bool {

    var zeroAddress = sockaddr_in(sin_len: 0, sin_family: 0, sin_port: 0, sin_addr: in_addr(s_addr: 0), sin_zero: (0, 0, 0, 0, 0, 0, 0, 0))
    zeroAddress.sin_len = UInt8(MemoryLayout.size(ofValue: zeroAddress))
    zeroAddress.sin_family = sa_family_t(AF_INET)

    let defaultRouteReachability = withUnsafePointer(to: &zeroAddress) {
        $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {zeroSockAddress in
            SCNetworkReachabilityCreateWithAddress(nil, zeroSockAddress)
        }
    }

    var flags: SCNetworkReachabilityFlags = SCNetworkReachabilityFlags(rawValue: 0)
    if SCNetworkReachabilityGetFlags(defaultRouteReachability!, &flags) == false {
        return false
    }

    let isReachable = (flags.rawValue & UInt32(kSCNetworkFlagsReachable)) != 0
    let needsConnection = (flags.rawValue & UInt32(kSCNetworkFlagsConnectionRequired)) != 0
    let ret = (isReachable && !needsConnection)

    return ret

}

So können Sie dies jetzt ganz einfach in Ihrer App aufrufen, wo immer Sie möchten

loadingJSON("yourDomain.com/login.php", postString:"email=\(userEmail!)&password=\(password!)") {
            parseJSON in

            if(String(describing: parseJSON) == "-1"){
                print("No Internet")
            } else {

                if let loginSuccessfull = parseJSON["loginSuccessfull"] as? Bool {
                    //... do stuff
                }
  }

Das Problem liegt bei der API-Interaktionsmethode. Die JSON-Analyse wird nur in Syntax geändert. Das Hauptproblem ist die Art und Weise, wie Daten abgerufen werden. Was Sie verwenden, ist ein synchroner Weg, um Daten abzurufen. Das funktioniert nicht in jedem Fall. Was Sie verwenden sollten, ist eine asynchrone Methode zum Abrufen von Daten. Auf diese Weise müssen Sie Daten über die API anfordern und darauf warten, dass sie mit Daten antworten. Dies erreichen Sie mit URL-Sitzungen und Bibliotheken von Drittanbietern wie Alamofire. Nachfolgend finden Sie die Sitzungsmethode für Code für URL. 

let urlString = "https://api.forecast.io/forecast/apiKey/37.5673776,122.048951"

let url = URL.init(string: urlString)
URLSession.shared.dataTask(with:url!) { (data, response, error) in
  guard error == nil else {
  print(error)
  }
  do {

    let Data = try JSONSerialization.jsonObject(with: data!) as! [String:Any] // Note if your data is coming in Array you should be using [Any]()
    //Now your data is parsed in Data variable and you can use it normally

    let currentConditions = Data["currently"] as! [String:Any]

    print(currentConditions)

    let currentTemperatureF = currentConditions["temperature"] as! Double
    print(currentTemperatureF)
  } catch let error as NSError {
    print(error)

  }

}.resume()

Swift hat einen mächtigen Typschluss. Lassen Sie uns "Wenn sich" oder "Wache lassen" entfernen, und zwingen Sie das Abwickeln mit einem funktionalen Ansatz:

1. Hier ist unser JSON. Wir können optionales JSON oder normal verwenden. Ich verwende optional in unserem Beispiel:

    let json: Dictionary<String, Any>? = ["current": ["temperature": 10]]

2. Hilfsfunktionen. Wir müssen sie nur einmal schreiben und dann mit jedem Wörterbuch wiederverwenden:

    /// Curry
    public func curry<A, B, C>(_ f: @escaping (A, B) -> C) -> (A) -> (B) -> C {
        return { a in
            { f(a, $0) }
        }
    }

    /// Function that takes key and optional dictionary and returns optional value
    public func extract<Key, Value>(_ key: Key, _ json: Dictionary<Key, Any>?) -> Value? {
        return json.flatMap {
            cast($0[key])
        }
    }

    /// Function that takes key and return function that takes optional dictionary and returns optional value
    public func extract<Key, Value>(_ key: Key) -> (Dictionary<Key, Any>?) -> Value? {
        return curry(extract)(key)
    }

    /// Precedence group for our operator
    precedencegroup RightApplyPrecedence {
        associativity: right
        higherThan: AssignmentPrecedence
        lowerThan: TernaryPrecedence
    }

    /// Apply. g § f § a === g(f(a))
    infix operator § : RightApplyPrecedence
    public func §<A, B>(_ f: (A) -> B, _ a: A) -> B {
        return f(a)
    }

    /// Wrapper around operator "as".
    public func cast<A, B>(_ a: A) -> B? {
        return a as? B
    }

3. Und hier ist unsere Magie - extrahieren Sie den Wert:

    let temperature = (extract("temperature") § extract("current") § json) ?? NSNotFound

Nur eine Codezeile und kein Force-Wrapping oder manuelles Casting. Dieser Code funktioniert auf dem Spielplatz, sodass Sie ihn kopieren und überprüfen können. Hier ist eine Implementierung auf GitHub.