parser - Analizando correctamente JSON en Swift 3

json swift

Question

Estoy tratando de obtener una respuesta JSON y almacenar los resultados en una variable. He tenido versiones de este código que funcionan 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 subíndice un valor de tipo ''AnyObject'' y JSON Parsing en Swift 3 .

Sin embargo, parece que las ideas transmitidas allí 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 parque infantil):

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és de print(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]

Answer 1

Construí quicktype exactamente para este propósito. Simplemente pegue su JSON de muestra y quicktype genera esta jerarquía de tipos para sus datos de 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 JSONSerialization.jsonObject sin dependencia para obtener el valor de retorno de JSONSerialization.jsonObject en un Forecast , incluido un constructor de conveniencia que toma una cadena JSON para que pueda analizar rápidamente un valor de Forecast fuertemente tipado y acceder a sus campos:

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

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

Answer 2

El problema está en el método de interacción de la API. El análisis JSON solo se cambia en la sintaxis. El principal problema es con la forma de obtener datos. Lo que está utilizando es una forma síncrona de obtener datos. Esto no funciona en todos los casos. Lo que deberías usar es una forma asincrónica de recuperar datos. De esta manera, debe solicitar datos a través de la API y esperar a que responda con datos. Puede lograr esto con una sesión de URL y bibliotecas de terceros como Alamofire. A continuación se muestra el código para el método de sesión 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()

Answer 3

En primer lugar, nunca cargue datos sincrónicamente desde una URL remota , use métodos siempre asíncronos como URLSession .

''Any'' no tiene miembros de subíndice

se produce porque el compilador no tiene idea de qué tipo son los objetos intermedios (por ejemplo, currently en ["currently"]!["temperature"] ) y dado que está utilizando tipos de colección de Foundation como NSDictionary el compilador no tiene ninguna idea sobre el tipo.

Además, en Swift 3 se requiere informar al compilador sobre el tipo de todos los objetos suscritos.

Debe convertir el resultado de la serialización JSON al tipo real.

Este código usa URLSession y tipos nativos exclusivamente Swift

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

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

      let parsedData = try JSONSerialization.jsonObject(with: data!) as! [String:Any]
      let currentConditions = parsedData["currently"] as! [String:Any]

      print(currentConditions)

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

}.resume()

Para imprimir todos los pares clave / valor de currentConditions , podría escribir

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

  for (key, value) in currentConditions {
    print("/(key) - /(value) ")
  }

Una nota sobre jsonObject(with data :

Muchos (parece que todos) los tutoriales sugieren opciones .mutableContainers o .mutableLeaves , lo cual es completamente absurdo en Swift. Las dos opciones son opciones heredadas de Objective-C para asignar el resultado a NSMutable... objetos. En Swift, cualquier variable es mutable por defecto y pasar cualquiera de esas opciones y asignar el resultado a una constante let no tiene ningún efecto. Además, la mayoría de las implementaciones nunca están mutando el JSON deserializado de todos modos.

La única opción (rara) que es útil en Swift es .allowFragments que es necesaria si el objeto raíz JSON podría ser un tipo de valor ( String , Number , Bool o null ) en lugar de uno de los tipos de colección ( array o dictionary ). Pero normalmente omite el parámetro de options , que significa Sin opciones .

================================================== =========================

Algunas consideraciones generales para analizar JSON

JSON es un formato de texto bien organizado. Es muy fácil leer una cadena JSON. Lee la cuerda cuidadosamente . Solo hay seis tipos diferentes: dos tipos de colección y cuatro tipos de valor.

Los tipos de colección son

• Matriz - JSON: objetos entre corchetes [] - Swift: [Any] pero en la mayoría de los casos [[String:Any]]
• Diccionario - JSON: objetos entre llaves {} - Swift: [String:Any]

Los tipos de valor son

• Cadena - JSON: cualquier valor entre comillas dobles "Foo" , incluso "123" o "false" - Swift: String
• Número - JSON: valores numéricos que no están entre comillas dobles 123 o 123.0 - Swift: Int o Double
• Bool - JSON: true o false no entre comillas dobles - Swift: true o false
• nulo - JSON: null - Swift: NSNull

De acuerdo con la especificación JSON, todas las claves en los diccionarios deben ser String .

Básicamente, siempre se recomienda utilizar enlaces opcionales para desenvolver los opcionales de forma segura

Si el objeto raíz es un diccionario ( {} ), envíe el tipo a [String:Any]

if let parsedData = try JSONSerialization.jsonObject(with: data!) as? [String:Any] { ...

y recuperar valores mediante claves con ( OneOfSupportedJSONTypes es una colección JSON o un tipo de valor como se describe anteriormente).

if let foo = parsedData["foo"] as? OneOfSupportedJSONTypes {
    print(foo)
} 

Si el objeto raíz es una matriz ( [] ), envíe el tipo a [[String:Any]]

if let parsedData = try JSONSerialization.jsonObject(with: data!) as? [[String:Any]] { ...

e iterar a través de la matriz con

for item in parsedData {
    print(item)
}

Si necesita un elemento en un índice específico, verifique también si el índice existe

if let parsedData = try JSONSerialization.jsonObject(with: data!) as? [[String:Any]], parsedData.count > 2,
   let item = parsedData[2] as? OneOfSupportedJSONTypes {
      print(item)
    }
}

En el raro caso de que JSON sea simplemente uno de los tipos de valor, en lugar de un tipo de colección, debe pasar la opción .allowFragments y emitir el resultado al tipo de valor apropiado, por ejemplo

if let parsedData = try JSONSerialization.jsonObject(with: data!, options: .allowFragments) as? String { ...

Apple ha publicado un artículo completo en el Blog de Swift: Trabajando con JSON en Swift

================================================== =========================

En Swift 4+, el protocolo Codable proporciona una forma más conveniente de analizar JSON directamente en estructuras / clases.

Por ejemplo, la muestra JSON dada en la pregunta (ligeramente modificada)

let jsonString = """
{"icon": "partly-cloudy-night", "precipProbability": 0, "pressure": 1015.39, "humidity": 0.75, "precip_intensity": 0, "wind_speed": 6.04, "summary": "Partly Cloudy", "ozone": 321.13, "temperature": 49.45, "dew_point": 41.75, "apparent_temperature": 47, "wind_bearing": 332, "cloud_cover": 0.28, "time": 1480846460}
"""

se puede decodificar en la estructura Weather . Los tipos Swift son los mismos que los descritos anteriormente. Hay algunas opciones adicionales:

• Las cadenas que representan una URL pueden decodificarse directamente como URL .
• El entero de time se puede decodificar como Date con dateDecodingStrategy .secondsSince1970 .
• Las claves JSON snaked_cased se pueden convertir a camelCase con keyDecodingStrategy .convertFromSnakeCase

struct Weather: Decodable {
    let icon, summary: String
    let pressure: Double, humidity, windSpeed : Double
    let ozone, temperature, dewPoint, cloudCover: Double
    let precipProbability, precipIntensity, apparentTemperature, windBearing : Int
    let time: Date
}

let data = Data(jsonString.utf8)
do {
    let decoder = JSONDecoder()
    decoder.dateDecodingStrategy = .secondsSince1970
    decoder.keyDecodingStrategy = .convertFromSnakeCase
    let result = try decoder.decode(Weather.self, from: data)
    print(result)
} catch {
    print(error)
}

Otras fuentes codificables:

• Apple: codificación y decodificación de tipos personalizados
• HackingWithSwift: Cheat Sheet codificable
• Ray Wenderlich: codificación y decodificación en Swift

Answer 4

Swift tiene una poderosa inferencia de tipos. Vamos a deshacernos de la placa repetitiva "if let" o "guard let" y forzar el desenvolvimiento utilizando un enfoque funcional:

1. Aquí está nuestro JSON. Podemos usar JSON opcional o habitual. Estoy usando opcional en nuestro ejemplo:

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

2. Funciones de ayuda. Necesitamos escribirlos solo una vez y luego reutilizarlos con cualquier diccionario:

    /// 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. Y aquí está nuestra magia: extraer el valor:

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

Solo una línea de código y sin desenredos forzados o fundición manual. Este código funciona en el patio de recreo, por lo que puede copiarlo y verificarlo. Aquí hay una implementación en GitHub.

Answer 5

Un gran cambio que sucedió con Xcode 8 Beta 6 para Swift 3 fue que la identificación ahora se importa como Any lugar de AnyObject .

Esto significa que parsedData se devuelve como un diccionario de lo más probable con el tipo [Any:Any] . Sin usar un depurador, no podría decirte exactamente qué hará tu lanzamiento a NSDictionary , ¡pero el error que estás viendo es porque dict!["currently"]! tiene tipo Any

Entonces, ¿cómo resuelves esto? Por la forma en que lo ha referenciado, supongo que dict!["currently"]! es un diccionario y por eso tienes 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 puede consultar para valores y así puede obtener su temperatura de esta manera:

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

O si lo prefiere, puede 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 JSON en [String: AnyObject] desde el principio.

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

Answer 6

Actualizó la función isConnectToNetwork después, gracias a esta publicación Compruebe la conexión a Internet con Swift

Escribí un método adicional para ello:

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

}

Así que ahora puedes llamar fácilmente a esto en tu aplicación donde quieras

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

Answer 7

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