Swift, NSJSONSerialization et NSError

Le problème est lorsqu'il existe des données incomplètes NSJSONSerialization.JSONObjectWithData est crash d'une application donnant unexpectedly found nil while unwrapping an Optional value d'erreur au lieu de nous en informer en utilisant NSError variable. Si nous sommes incapables de prévenir l'accident.

Vous pouvez trouver le code que nous utilisons ci-dessous

      var error:NSError? = nil

      let dataToUse = NSJSONSerialization.JSONObjectWithData(receivedData, options:   NSJSONReadingOptions.AllowFragments, error:&error) as NSDictionary

    if error != nil { println( "There was an error in NSJSONSerialization") }

Jusqu'à maintenant, nous sommes incapables de trouver un travail autour de.

InformationsquelleAutor Hope | 2015-01-13

24

Le problème, c'est que vous lancez le résultat au format JSON désérialisation avant
vérifier qu'une erreur. Si les données JSON n'est pas valide (par exemple, incomplets) alors
```
NSJSONSerialization.JSONObjectWithData(...)
```
retourne nil et
```
NSJSONSerialization.JSONObjectWithData(...) as NSDictionary
```
en panne.

Ici est une version qui vérifie les conditions d'erreur correctement:
```
var error:NSError? = nil
if let jsonObject: AnyObject = NSJSONSerialization.JSONObjectWithData(receivedData, options: nil, error:&error) {
    if let dict = jsonObject as? NSDictionary {
        println(dict)
    } else {
        println("not a dictionary")
    }
} else {
    println("Could not parse JSON: \(error!)")
}
```
Remarques:
- La bonne façon de vérifier une erreur est à l'épreuve de la valeur de retour, pas la
  variable d'erreur.
- Le JSON de lecture option .AllowFragments ne sont pas utiles ici. Le réglage de cette option
  permet seulement que les objets de plus haut niveau qui ne sont pas une instance de NSArray ou NSDictionary, par exemple
```
{ "someString" }
```
Vous pouvez aussi le faire en une seule ligne, avec un en fonte as?:
```
if let dict = NSJSONSerialization.JSONObjectWithData(receivedData, options: nil, error:nil) as? NSDictionary {
    println(dict)
} else {
    println("Could not read JSON dictionary")
}
```
L'inconvénient est que, dans le else cas, vous ne pouvez pas distinguer si la lecture de
les données JSON a échoué ou si le JSON ne représentent pas un dictionnaire.

Pour une mise à jour de Swift 3, voir LightningStryk réponse.
- La partie a expliqué que "Ici est une version qui vérifie les conditions d'erreur correctement" n'est pas la capture de l'erreur. Il est écrasé à la ligne malheureusement laissé dataToUse: AnyObject = NSJSONSerialization.JSONObjectWithData(receivedData, options: NSJSONReadingOptions.AllowFragments, erreur:&erreur)! Je voudrais dire que cette précédente codes que j'ai soumis fonctionne très bien dans le cas de il n'y a pas de problème avec les données reçues.
- Ce n'est pas exactement ce que j'ai suggéré. Si vous avec force déballer le résultat avec ! alors vous avez le même problème qu'avec l'forcé cast as NSDictionary: Il va se planter si le résultat est nul.
- laissez dataToUse: AnyObject? = NSJSONSerialization.JSONObjectWithData(receivedData, options: NSJSONReadingOptions.AllowFragments, erreur:&erreur) Semble être OK. Donc, je suis à la vérification de question que de réponse par vous. Au moins votre compréhension du sujet, c'est mieux.
InformationsquelleAutor Martin R

Mis à jour pour Swift 3

let jsonData = Data()
do {
    let jsonObject = try JSONSerialization.jsonObject(with: jsonData, options:JSONSerialization.ReadingOptions(rawValue: 0))
    guard let dictionary = jsonObject as? Dictionary<String, Any> else {
        print("Not a Dictionary")
        //put in function
        return
    }
    print("JSON Dictionary! \(dictionary)")
}
catch let error as NSError {
    print("Found an error - \(error)")
}

Swift 2

let JSONData = NSData()
do {
    let JSON = try NSJSONSerialization.JSONObjectWithData(JSONData, options:NSJSONReadingOptions(rawValue: 0))
    guard let JSONDictionary: NSDictionary = JSON as? NSDictionary else {
        print("Not a Dictionary")
        //put in function
        return
    }
    print("JSONDictionary! \(JSONDictionary)")
}
catch let JSONError as NSError {
    print("\(JSONError)")
}

ouch swift a vraiment énormément de syntaxe par rapport à objc. "laisser", "faire", "essayer", "gardien", "que?", "attraper"...autant de jargon.
Il serait mieux si vous pouviez juste attraper l'exception d'exécution de l'échec de jeter à la NSDictionary, ne peut pas croire qu'ils avaient à l'ajout d'un nouveau mot-clé de la garde juste pour rendre cela possible.
À l'aide de la première capitale des lettres pour les noms de variables est une mauvaise idée, vous embrouiller les gens. Mais en même temps, merci pour cette réponse.
Si la variable est un acronyme (par exemple, JSON, URL, etc.) Je préfère capitaliser le mot en entier, sinon, il semble étrange (jSON, uRL)

InformationsquelleAutor LightningStryk

Swift 3:

let jsonData = Data()
do {
    guard let parsedResult = try JSONSerialization.jsonObject(with: jsonData, options: .allowFragments) as? NSDictionary else {
        return
    }
    print("Parsed Result: \(parsedResult)")
} catch {
    print("Error: \(error.localizedDescription)")
}

InformationsquelleAutor Ashok R

Ici est une Swift 2 extension que vous pouvez utiliser pour deserialise seulement un NSDictionary:

extension NSJSONSerialization{
    public class func dictionaryWithData(data: NSData, options opt: NSJSONReadingOptions) throws -> NSDictionary{
        guard let d: NSDictionary = try self.JSONObjectWithData(data, options:opt) as? NSDictionary else{
            throw NSError(domain: NSURLErrorDomain, code: NSURLErrorCannotParseResponse, userInfo: [NSLocalizedDescriptionKey : "not a dictionary"])
        }
        return d;
    }
}

Désolé je n'étais pas sûr de savoir comment faire un garde-retour afin d'éviter la création de la temporaire de "d".

InformationsquelleAutor malhal

Swift 3 NSJSONSerialization de l'échantillon (lire json à partir d'un fichier):

fichier de données.json (exemple ici: http://json.org/example.html)

{
"glossary":{
"title":"example glossary",
"GlossDiv":{
    "title":"S",
    "GlossList":{
        "GlossEntry":{
            "ID":"SGML",
            "SortAs":"SGML",
            "GlossTerm":"Standard Generalized Markup Language",
            "Acronym":"SGML",
            "Abbrev":"ISO 8879:1986",
            "GlossDef":{
                "para":"A meta-markup language, used to create markup languages such as DocBook.",
                "GlossSeeAlso":[
                                "GML",
                                "XML"
                                ]
            },
            "GlossSee":"markup"
        }
    }
}
}
}

fichier JSONSerialization.swift

extension JSONSerialization {

enum Errors: Error {
    case NotDictionary
    case NotJSONFormat
}

public class func dictionary(data: Data, options opt: JSONSerialization.ReadingOptions) throws -> NSDictionary {
    do {
        let JSON = try JSONSerialization.jsonObject(with: data , options:opt)
        if let JSONDictionary = JSON as? NSDictionary {
            return JSONDictionary
        }
        throw Errors.NotDictionary
    }
    catch {
        throw Errors.NotJSONFormat
    }
}
}

Utilisation

 func readJsonFromFile() {
    if let path = Bundle.main.path(forResource: "data", ofType: "json") {
        if let data = NSData(contentsOfFile: path) as? Data {

            do {
                let dict = try JSONSerialization.dictionary(data: data, options: .allowFragments)
                print(dict)
            } catch let error {
                print("\(error)")
            }

        }
    }
}

Résultat (journal capture d'écran)

Swift, NSJSONSerialization et NSError

InformationsquelleAutor Vasily Bodnarchuk

Vous devez vous connecter pour publier un commentaire.