Travailler avec JSON en Swift : parsing et sérialisation pour iOS et macOS

Travailler avec JSON en Swift : analyse et sérialisation

JSON (JavaScript Object Notation) est un format léger d'échange de données, largement utilisé dans les services web et les applications mobiles. Dans l'écosystème Apple (iOS, macOS, watchOS, tvOS), travailler avec JSON est une partie intégrante du développement : du chargement de données depuis un serveur à la sauvegarde des paramètres d'application. Dans cet article, nous allons examiner en détail comment effectuer l'analyse (décodage) et la sérialisation (encodage) de JSON en Swift, en utilisant les protocoles intégrés Codable, JSONDecoder et JSONEncoder.

1. Bases de Codable : modèle de données

L'approche moderne pour travailler avec JSON en Swift est basée sur le protocole Codable, qui combine deux protocoles : Encodable (pour la sérialisation) et Decodable (pour l'analyse). Pour que votre structure ou classe puisse être convertie en JSON et vice versa, il suffit de la déclarer comme Codable.

Considérons un exemple de modèle d'utilisateur :

struct User: Codable {    let id: Int    let name: String    let email: String    let isActive: Bool}

Si les clés dans le JSON diffèrent des noms de propriétés en Swift (par exemple, snake_case est utilisé au lieu de camelCase), vous pouvez utiliser l'énumération CodingKeys :

struct User: Codable {    let id: Int    let fullName: String    let email: String    let isActive: Bool

    enum CodingKeys: String, CodingKey {        case id        case fullName = "full_name"        case email        case isActive = "is_active"    }}

2. Analyse JSON avec JSONDecoder

Pour convertir une chaîne JSON ou des données en objets Swift, on utilise JSONDecoder. La méthode principale est decode(_:from:), qui prend un type de données (conforme à Decodable) et un objet Data.

Exemple d'analyse d'une chaîne JSON reçue d'une API :

let jsonString = """{    "id": 1,    "name": "Ivan Petrov",    "email": "ivan@example.com",    "is_active": true}"""

let jsonData = Data(jsonString.utf8)

do {    let decoder = JSONDecoder()    let user = try decoder.decode(User.self, from: jsonData)    print("Utilisateur : \\(user.name), email : \\(user.email)")} catch {    print("Erreur de décodage : \\(error.localizedDescription)")}

Souvent, le JSON arrive sous forme de tableau d'objets. Dans ce cas, spécifiez simplement le type [User].self :

let jsonArrayString = """[    {"id": 1, "name": "Ivan", "email": "ivan@test.com", "is_active": true},    {"id": 2, "name": "Maria", "email": "maria@test.com", "is_active": false}]"""

let jsonArrayData = Data(jsonArrayString.utf8)

do {    let users = try JSONDecoder().decode([User].self, from: jsonArrayData)    users.forEach { print($0.name) }} catch {    print("Erreur : \\(error)")}

3. Sérialisation d'objets en JSON avec JSONEncoder

Le processus inverse — conversion d'un objet Swift en JSON — est effectué à l'aide de JSONEncoder. La méthode encode(_:) retourne un objet Data, qui peut ensuite être converti en chaîne ou envoyé au serveur.

let user = User(id: 3, fullName: "Alexei Smirnov", email: "alex@example.com", isActive: true)

do {    let encoder = JSONEncoder()    encoder.outputFormatting = .prettyPrinted // pour un formatage lisible    let jsonData = try encoder.encode(user)    if let jsonString = String(data: jsonData, encoding: .utf8) {        print(jsonString)    }} catch {    print("Erreur d'encodage : \\(error)")}

Le résultat ressemblera à ceci :

{  "id" : 3,  "full_name" : "Alexei Smirnov",  "email" : "alex@example.com",  "is_active" : true}

Notez que le JSO