Codable et JSON

Codable et JSON

Comment ça fonctionne ? Pour faire simple, des données sous format JSON sont stockées sur un serveur. Moi, avec mon application, je vais faire une requête vers ce serveur afin de récupérer les données du JSON dans mon programme. Une fois que j’ai réussi à récupérer les données JSON, je vais devoir traduire les données du format JSON en un format de données que je pourrai lire dans mon programme en Swift, un objet par exemple. Je t’explique en détail les bases du JSON et comment on va traduire ces données dans notre programme :

Structure du JSON

Un fichier JSON est composé de paires clé-valeur et de listes de valeurs. Je te présente les composants de base.

Types de données JSON

Number (ex : 10, 3.14)

String (ex : "Salut")

Bool (ex : true, false)

Array (ex : ["Pomme", "Mangue", "Fraise"])

Object (ex : {"prenom": "Sarah", "nom": "Connor"})

null

Syntaxe

{
    "name": "Harry Potter",
    "age": 20,
    "isWizard": true
}

Tableau

[
    "Harry Potter",
    "Hermione Granger",
    "Ron Weasley"
]

Comme en Swift, les valeurs sont entourées de crochets [].

Objet

{
    "House": "Griffondor",
    "students": [
        { "name": "Harry Potter", "age": 20 },
        { "name": "Hermione Granger", "age": 20 },
        { "name": "Ron Weasley", "age": 20 }
    ]
}

Lire des Données JSON en Swift avec le Protocole Codable

Définir les Structures

Pour utiliser le protocole Codable, je vais définir des structures qui correspondent à la structure du JSON. Chaque clé du JSON doit avoir une propriété correspondante dans notre structure. Par exemple :

JSON

{
    "name": "Harry Potter",
    "age": 20,
    "isWizard": true
}

Structure correspondante

struct Student: Codable {
    var name: String
    var age: Int
    var isWizard: Bool
}

Ici, Student adopte le protocole Codable. Ça signifie que cette structure peut être encodée et décodée à partir du JSON.

Décoder les données JSON

J’ai volontairement créé une constante comprenant du JSON jsonData. Normalement, tu chargerais ton JSON depuis une URL ou un fichier.

let jsonData = """
{
    "name": "Harry Potter",
    "age": 20,
    "isWizard": true
}
""".data(using: .utf8)!

do {
    let student = try JSONDecoder().decode(Student.self, from: jsonData)
    print("Nom: \(student.name), Âge: \(student.age), Est Sorcier: \(student.isWizard)")
} catch {
    print("Erreur de décodage: \(error)")
}

C’est une opération qui à un risque d’erreur (nous n’avons pas toujours le contrôle sur les données d’un JSON vu que ce sont souvent des données externes à nos programmes)

Une bonne pratique est d’utiliser un bloc do try catch pour rappel do va lancer le bloc de code, try va lancer le code qui peut générer une erreur et catch va capturer l’erreur si il y a.

Intéressons nous maintenant à notre JSONDecoder, qui est une classe fournit par swift pour décoder des données JSON en instance d’objet. Pour utiliser JSONDecoder les types que l’on souhaite convertir doivent être conforme au protocole Codable (comme nous l’avons déjà paramétrer sur notre struct Student)

JSONDecoder.().decode(Student.self, from: data) dans notre exemple on utilise la méthode .decode qui demande a JSONDecoder de convertir les données du JSON contenu dans data en une instance du type Student. Si le décodage réussit, student devient une instance de Student remplie avec les données extraites du JSON.

On peut enfin afficher notre titre dans la console print("Nom: \\(student.name), Âge: \\(student.age), Est Sorcier: \\(student.isWizard)")

  Décoder un tableau JSON

let jsonArrayData = """
[
    {
        "name": "Harry Potter",
        "age": 20,
        "isWizard": true
    },
    {
        "name": "Hermione Granger",
        "age": 20,
        "isWizard": true
    },
    {
        "name": "Ron Weasley",
        "age": 20,
        "isWizard": true
    }
]
""".data(using: .utf8)!

do {
    let students = try JSONDecoder().decode([Student].self, from: jsonArrayData)
    for student in students {
        print("Nom: \(student.name), Âge: \(student.age), Est Sorcier: \(student.isWizard)")
    }
} catch {
    print("Erreur de décodage: \(error)")
}

}

 Décoder un Objet

{
    "House": "Griffondor",
    "students": [
        { "name": "Harry Potter", "age": 20 },
        { "name": "Hermione Granger", "age": 20 },
        { "name": "Ron Weasley", "age": 20 }
    ]
}

Cette fois, on va décoder un objet JSON. C’est là qu’il faut prendre le temps d’analyser comment est fait l’objet à traduire pour bien le faire correspondre à notre programme. Ici, on peut observer deux valeurs distinctes : House pour représenter une maison, et students qui représentent les élèves affiliés à cette maison. La bonne pratique serait de créer deux structures indépendantes pour les représenter dans notre code.

struct Student: Codable {
    var name: String
    var age: Int
}

struct House: Codable {
    var House: String
    var students: [Student]
}

Un objet seul

let jsonData = """
{
    "House": "Griffondor",
    "students": [
        { "name": "Harry Potter", "age": 20 },
        { "name": "Hermione Granger", "age": 20 },
        { "name": "Ron Weasley", "age": 20 }
    ]
}
""".data(using: .utf8)!


do {
    let griffondor = try JSONDecoder().decode(House.self, from: jsonData)
    print("Maison: \(griffondor.House)")
    for student in griffondor.students {
        print("Nom: \(student.name), Âge: \(student.age)")
    }
} catch {
    print("Erreur de décodage: \(error)")
}

Un tableau d’objet

let jsonData = """
[
    {
        "House": "Griffondor",
        "students": [
            { "name": "Harry Potter", "age": 20 },
            { "name": "Hermione Granger", "age": 20 },
            { "name": "Ron Weasley", "age": 20 }
        ]
    },
    {
        "House": "Serpentard",
        "students": [
            { "name": "Draco Malfoy", "age": 20 },
            { "name": "Pansy Parkinson", "age": 20 },
            { "name": "Gregory Goyle", "age": 20 }
        ]
    }
]
""".data(using: .utf8)!


do {
    let houses = try JSONDecoder().decode([House].self, from: jsonData)
    for house in houses {
        print("Maison: \(house.House)")
        for student in house.students {
            print("Nom: \(student.name), Âge: \(student.age)")
        }
        print("-----")
    }
} catch {
    print("Erreur de décodage: \(error)")
}

Encoder

struct Student: Codable {
    var name: String
    var age: Int
    var isWizard: Bool
}

let harry = Student(name: "Harry Potter", age: 20, isWizard: true)

do {
    let jsonData = try JSONEncoder().encode(harry)
    if let jsonString = String(data: jsonData, encoding: .utf8) {
        print("JSON String : \(jsonString)")
    }
} catch {
    print("Erreur d'encodage : \(error)")
}

Avec le protocole Codable, nous avons vu comment décoder des données au format JSON en objet Swift. Ce protocole nous permet également d’encoder un objet Swift en JSON. Comme dans l’exemple ci-dessus, nous utilisons la méthode JSONEncoder() pour transformer harry d’un objet Swift en une donnée JSON. Cela sera particulièrement utile si tu souhaites envoyer des données de ton application vers un serveur distant traitant ces données en JSON.