Swift Codable

struct User: Codable {    let id: Int    let name: String    let email: String    let isVerified: Bool}
let user = try JSONDecoder().decode(User.self, from: jsonData)let encoded = try JSONEncoder().encode(user)

struct Product: Codable {    let id: Int    let displayName: String    let imageURL: URL    let priceInCents: Int
    enum CodingKeys: String, CodingKey {        case id        case displayName = "display_name"        case imageURL = "image_url"        case priceInCents = "price_in_cents"    }}

struct Event: Codable {    let name: String    let timestamp: Date    let tags: [String]
    enum CodingKeys: String, CodingKey {        case name, timestamp, tags    }
    init(from decoder: Decoder) throws {        let container = try decoder.container(keyedBy: CodingKeys.self)        name = try container.decode(String.self, forKey: .name)        // Decode Unix timestamp as Double, convert to Date        let epoch = try container.decode(Double.self, forKey: .timestamp)        timestamp = Date(timeIntervalSince1970: epoch)        // Default to empty array when key is missing        tags = try container.decodeIfPresent([String].self, forKey: .tags) ?? []    }
    func encode(to encoder: Encoder) throws {        var container = encoder.container(keyedBy: CodingKeys.self)        try container.encode(name, forKey: .name)        try container.encode(timestamp.timeIntervalSince1970, forKey: .timestamp)        try container.encode(tags, forKey: .tags)    }}

// JSON: { "id": 1, "location": { "lat": 37.7749, "lng": -122.4194 } }struct Place: Decodable {    let id: Int    let latitude: Double    let longitude: Double
    enum CodingKeys: String, CodingKey { case id, location }    enum LocationKeys: String, CodingKey { case lat, lng }
    init(from decoder: Decoder) throws {        let container = try decoder.container(keyedBy: CodingKeys.self)        id = try container.decode(Int.self, forKey: .id)        let location = try container.nestedContainer(            keyedBy: LocationKeys.self, forKey: .location)        latitude = try location.decode(Double.self, forKey: .lat)        longitude = try location.decode(Double.self, forKey: .lng)    }}

let decoder = JSONDecoder()
// ISO 8601 (e.g., "2024-03-15T10:30:00Z")decoder.dateDecodingStrategy = .iso8601
// Unix timestamp in seconds (e.g., 1710499800)decoder.dateDecodingStrategy = .secondsSince1970
// Custom DateFormatterlet formatter = DateFormatter()formatter.dateFormat = "yyyy-MM-dd"formatter.locale = Locale(identifier: "en_US_POSIX")formatter.timeZone = TimeZone(secondsFromGMT: 0)decoder.dateDecodingStrategy = .formatted(formatter)
// Custom closure for multiple formatsdecoder.dateDecodingStrategy = .custom { decoder in    let container = try decoder.singleValueContainer()    let string = try container.decode(String.self)    if let date = ISO8601DateFormatter().date(from: string) { return date }    throw DecodingError.dataCorruptedError(        in: container, debugDescription: "Cannot decode date: \(string)")}

let decoder = JSONDecoder()decoder.dataDecodingStrategy = .base64           // Base64-encoded Data fieldsdecoder.keyDecodingStrategy = .convertFromSnakeCase  // simple keys only; not URL/ID spelling// {"user_name": "Alice"} maps to `var userName: String` -- no CodingKeys needed
let encoder = JSONEncoder()encoder.dataEncodingStrategy = .base64encoder.keyEncodingStrategy = .convertToSnakeCase

func fetchUser(id: Int) async throws -> User {    let url = URL(string: "https://api.example.com/users/\(id)")!    let (data, response) = try await URLSession.shared.data(from: url)    guard let http = response as? HTTPURLResponse,          (200...299).contains(http.statusCode) else {        throw APIError.invalidResponse    }    let decoder = JSONDecoder()    decoder.keyDecodingStrategy = .convertFromSnakeCase    decoder.dateDecodingStrategy = .iso8601    return try decoder.decode(User.self, from: data)}
// Generic API envelope. Configure a decoder inside this helper because// fetchUser's decoder is out of scope.struct APIResponse<T: Decodable>: Decodable {    let data: T    let meta: Meta?    struct Meta: Decodable { let page: Int; let totalPages: Int }}
func decodeUsersEnvelope(from data: Data) throws -> [User] {    let decoder = JSONDecoder()    decoder.keyDecodingStrategy = .convertFromSnakeCase    decoder.dateDecodingStrategy = .iso8601    return try decoder.decode(APIResponse<[User]>.self, from: data).data}

// DON'T -- crashes if key is absentlet value = try container.decode(String.self, forKey: .bio)// DO -- falls back when the key is absent or nulllet value = try container.decodeIfPresent(String.self, forKey: .bio) ?? ""

// DON'T -- one bad element kills the whole decodelet items = try container.decode([Item].self, forKey: .items)// DO -- decode elements individually only when partial success is allowed

// DON'T -- default strategy expects Double, but API sends ISO stringlet decoder = JSONDecoder()  // dateDecodingStrategy defaults to .deferredToDate// DO -- set strategy to match your API formatdecoder.dateDecodingStrategy = .iso8601

// DON'Tlet user = try? decoder.decode(User.self, from: data)print(user!.name)// DOguard let user = try? decoder.decode(User.self, from: data) else { return }

// DON'T -- unnecessarily constrains the type to also be Encodablestruct APIResponse: Codable { let id: Int; let message: String }// DO -- use Decodable for read-only API responsesstruct APIResponse: Decodable { let id: Int; let message: String }

// DON'T -- verbose boilerplate for every modelenum CodingKeys: String, CodingKey {    case userName = "user_name"    case avatarUrl = "avatar_url"}// DO -- configure once on the decoder for simple casesdecoder.keyDecodingStrategy = .convertFromSnakeCase// Keep CodingKeys for `imageURL`, `baseURI`, `userID`, and similar names.