Analizando correctamente JSON en Swift 3

Estoy intentando obtener una respuesta JSON y almacenar los resultados en una variable. He tenido versiones de este código funcionando en versiones anteriores de Swift, hasta que se lanzó la versión GM de Xcode 8. Eché un vistazo a algunas publicaciones similares en StackOverflow: Swift 2 Parsing JSON: no se puede subscribir un valor de tipo 'AnyObject' y JSON Parsing en Swift 3 .

Sin embargo, parece que las ideas allí transmitidas no se aplican en este escenario.

¿Cómo analizo correctamente la respuesta JSON en Swift 3? ¿Ha cambiado algo en la forma en que se lee JSON en Swift 3?

A continuación se muestra el código en cuestión (se puede ejecutar en un patio de juegos):

import Cocoa

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

if let url = NSURL(string: url) {
    if let data = try? Data(contentsOf: url as URL) {
        do {
            let parsedData = try JSONSerialization.jsonObject(with: data as Data, options: .allowFragments)

        //Store response in NSDictionary for easy access
        let dict = parsedData as? NSDictionary

        let currentConditions = "\(dict!["currently"]!)"

        //This produces an error, Type 'Any' has no subscript members
        let currentTemperatureF = ("\(dict!["currently"]!["temperature"]!!)" as NSString).doubleValue

            //Display all current conditions from API
            print(currentConditions)

            //Output the current temperature in Fahrenheit
            print(currentTemperatureF)

        }
        //else throw an error detailing what went wrong
        catch let error as NSError {
            print("Details of JSON parsing error:\n \(error)")
        }
    }
}

Editar: aquí hay una muestra de los resultados de la llamada API despuésprint(currentConditions)

["icon": partly-cloudy-night, "precipProbability": 0, "pressure": 1015.39, "humidity": 0.75, "precipIntensity": 0, "windSpeed": 6.04, "summary": Partly Cloudy, "ozone": 321.13, "temperature": 49.45, "dewPoint": 41.75, "apparentTemperature": 47, "windBearing": 332, "cloudCover": 0.28, "time": 1480846460]

Sep 10 '16 13:09 user2563039

Un gran cambio que ocurrió con Xcode 8 Beta 6 para Swift 3 fue que id ahora se importa como Anyen lugar de AnyObject.

Esto significa que parsedDatase devuelve como un diccionario probablemente con el tipo [Any:Any]. Sin usar un depurador, no podría decirle exactamente qué NSDictionaryhará su conversión, pero el error que está viendo se debe a que dict!["currently"]!tiene tipoAny

Entonces, ¿cómo se soluciona esto? Por la forma en que lo ha referenciado, supongo dict!["currently"]!que es un diccionario y, por lo tanto, tiene muchas opciones:

Primero podrías hacer algo como esto:

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

Esto le dará un objeto de diccionario que luego podrá consultar para obtener valores y así obtener su temperatura de esta manera:

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

O si lo prefieres puedes hacerlo en línea:

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

Espero que esto ayude, me temo que no he tenido tiempo de escribir una aplicación de muestra para probarla.

Una nota final: lo más fácil de hacer podría ser simplemente lanzar la carga útil JSON [String: AnyObject]desde el principio.

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

Sep 10 '2016 07:09 discorevilo

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)")
}

Jan 24 '2017 05:01 BhuShan PaWar

Construí QuickType exactamente para este propósito. Simplemente pegue su JSON de muestra y QuickType generará esta jerarquía de tipos para sus datos API:

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
}

También genera código de clasificación libre de dependencias para convertir el valor de retorno de JSONSerialization.jsonObjecten a Forecast, incluido un práctico constructor que toma una cadena JSON para que pueda analizar rápidamente un Forecastvalor fuertemente tipado y acceder a sus campos:

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

Puede instalar Quicktype desde npm npm i -g quicktypeo usar la interfaz de usuario web para obtener el código generado completo y pegarlo en su área de juegos.

Oct 14 '2017 05:10 David Siegel