JSON Parsing and Codable

# CHAPTER 19

JSON Parsing and Codable #

1. Introduction #

2. Learning Objectives #

• Read and understand raw JSON data structures.

• Create Swift Models that perfectly mirror JSON layouts.

• Conform models to the Codable protocol.

• Utilize JSONDecoder to translate raw binary Data into Swift objects.

• Handle nested JSON objects.

3. Understanding JSON #

Imagine an API endpoint https://api.example.com/user returns this JSON:

{
  "id": 101,
  "name": "Leanne Graham",
  "email": "leanne@gmail.com"
}

4. The Codable Protocol (The Blueprint) #

import Foundation

// 1. Matches the JSON structure exactly!
// 2. Conforms to Codable!
struct APIUser: Codable, Identifiable {
    let id: Int
    let name: String
    let email: String
}

5. Using JSONDecoder (The Translator) #

@MainActor
class UserViewModel: ObservableObject {
    @Published var users: [APIUser] = [] // We will store the parsed data here!
    
    func fetchUsers() async {
        guard let url = URL(string: "https://jsonplaceholder.typicode.com/users") else { return }
        
        do {
            // 1. Fetch the raw binary Data
            let (data, _) = try await URLSession.shared.data(from: url)
            
            // 2. The Magic Translation!
            // We tell the Decoder: "Try to decode this raw data into an Array of APIUser structs!"
            let decodedData = try JSONDecoder().decode([APIUser].self, from: data)
            
            // 3. Success! Update the UI Array!
            self.users = decodedData
            
        } catch {
            print("Failed to decode JSON: \(error)")
        }
    }
}

6. Handling Mismatched Keys (CodingKeys) #

You must provide a translation dictionary inside your struct called CodingKeys!

// The ugly JSON
{
  "user_id": 99,
  "first_name": "Bob"
}

struct CustomUser: Codable {
    let id: Int
    let firstName: String
    
    // The Translation Dictionary!
    enum CodingKeys: String, CodingKey {
        case id = "user_id"         // Maps 'id' to 'user_id'
        case firstName = "first_name" // Maps 'firstName' to 'first_name'
    }
}

7. Mini Project: The Full API Pipeline #

import SwiftUI

struct NetworkUser: Codable, Identifiable {
    let id: Int
    let name: String
    let username: String
}

@MainActor
class NetworkViewModel: ObservableObject {
    @Published var userList: [NetworkUser] = []
    
    func downloadData() async {
        guard let url = URL(string: "https://jsonplaceholder.typicode.com/users") else { return }
        do {
            let (data, _) = try await URLSession.shared.data(from: url)
            let parsedUsers = try JSONDecoder().decode([NetworkUser].self, from: data)
            self.userList = parsedUsers
        } catch {
            print("Error: \(error)")
        }
    }
}

struct ApiListView: View {
    @StateObject private var vm = NetworkViewModel()
    
    var body: some View {
        NavigationStack {
            List(vm.userList) { user in
                VStack(alignment: .leading) {
                    Text(user.name).font(.headline)
                    Text("@\(user.username)").foregroundColor(.gray)
                }
            }
            .navigationTitle("Live Users")
            .task {
                // .task is like .onAppear, but specifically built for async functions!
                await vm.downloadData()
            }
        }
    }
}

8. Common Mistakes #

• Type Mismatches: If the JSON says "id": 101 (an Integer), but your Swift struct says let id: String, the JSONDecoder will instantly throw a catastrophic error and fail the entire parsing process. The data types must match the JSON payload with 100% accuracy.

• Missing Optionality: If an API sometimes returns an "age" field, and sometimes completely omits it, your Swift struct MUST define it as optional: let age: Int?. If it is not optional, and the field is missing in the JSON, the parser crashes.

9. Best Practices #

• Print the Error: If your do-catch block is failing, do not just print("Failed"). ALWAYS print error. The Swift JSONDecoder is brilliant; it will specifically tell you exactly which key failed: *"Expected Int for key 'score' but found String"*.

10. Exercises #

1. 1. Look at this JSON: {"title": "Matrix", "year": 1999}. Write a Swift struct that conforms to Codable to match this layout.

1. 2. If you want to use the variable let movieTitle: String instead of title, write the CodingKeys enum to map it correctly.

11. Coding Challenges #

12. MCQ Quiz with Answers #

13. Interview Questions #

• Q: Explain the mechanical interaction between a REST API JSON payload, the Codable protocol, and the JSONDecoder class.

• Q: Describe a scenario where implementing a custom CodingKeys enumeration is architecturally mandatory for a Codable model.

• Q: Why must API fields that represent unstable or inconsistent data (e.g., a "middle_name" field that only appears for 50% of users) be strictly marked as Optionals (?) within the Swift model?

14. FAQs #

15. Summary #

16. Next Chapter Recommendation #