20 · Codable ② 전략·진단·성능

[imageURL] encode -> {"image_url":"https:\/\/x"}
[imageURL] decode -> 실패! keyNotFound: imageURL / No value associated with key CodingKeys(stringValue: "imageURL", intValue: nil) ("imageURL").
[xmlHTTPRequest] encode -> {"xml_http_request":"v"}
[xmlHTTPRequest] decode -> 실패! keyNotFound: xmlHTTPRequest / No value associated with key CodingKeys(stringValue: "xmlHTTPRequest", intValue: nil) ("xmlHTTPRequest").

import Foundation

struct Item: Codable { var imageURL: String }

let encoder = JSONEncoder()
encoder.keyEncodingStrategy = .convertToSnakeCase
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase

let data = try! encoder.encode(Item(imageURL: "https://x"))
print(String(data: data, encoding: .utf8)!)   // {"image_url":"https:\/\/x"}

do {
    let back = try decoder.decode(Item.self, from: data)
    print("성공:", back)
} catch {
    print("실패:", error)   // keyNotFound: imageURL
}

struct Article: Codable {
    let title: String        // user_id 류 평범한 단어는 전략으로 충분
    let viewCount: Int
    let imageURL: String     // 약어 포함 — 전략에 맡기면 깨지므로 명시

    enum CodingKeys: String, CodingKey {
        case title
        case viewCount
        case imageURL = "image_url"   // 전략을 끈 채로 이 필드만 직접 매핑한다는 전제
    }
}

struct SafeArticle: Codable {
    let title: String
    let viewCount: Int
    let imageURL: String

    enum CodingKeys: String, CodingKey {
        case title
        case viewCount = "view_count"
        case imageURL = "image_url"
    }
}
// decoder.keyDecodingStrategy 는 .useDefaultKeys(기본값) 그대로 둔다 — 전략과 섞지 않는다

struct Address: Codable { let city: String; let zip: Int }
struct User: Codable { let name: String; let address: Address }

let bad = #"{"name":"kim","address":{"city":"Seoul","zip":"12345"}}"#.data(using: .utf8)!
do {
    _ = try JSONDecoder().decode(User.self, from: bad)
} catch let DecodingError.typeMismatch(type, context) {
    print(context.codingPath.map(\.stringValue))   // ["address", "zip"]
    print(context.debugDescription)                 // Expected to decode Int but found a string instead.
}

import Foundation

/// 어떤 DecodingError든 "어느 필드에서, 무엇을 기대했고, 무엇이 왔는지"로 바꾼다.
func humanReadable(_ error: Error) -> String {
    guard let decodingError = error as? DecodingError else {
        return "디코딩과 무관한 에러: \(error)"
    }

    func pathString(_ path: [CodingKey]) -> String {
        path.isEmpty ? "(최상위)" : path.map { key -> String in
            if let intValue = key.intValue { return "[\(intValue)]" }
            return key.stringValue
        }.joined(separator: ".")
    }

    switch decodingError {
    case let .typeMismatch(type, context):
        return "'\(pathString(context.codingPath))' 필드: \(type) 타입을 기대했지만 다른 타입의 값이 왔다. (\(context.debugDescription))"
    case let .valueNotFound(type, context):
        return "'\(pathString(context.codingPath))' 필드: \(type) 값이 필요한데 null이 왔다. (\(context.debugDescription))"
    case let .keyNotFound(key, context):
        let parent = pathString(context.codingPath)
        return "'\(parent)' 아래에 '\(key.stringValue)' 키가 없다. (\(context.debugDescription))"
    case let .dataCorrupted(context):
        return "'\(pathString(context.codingPath))' 지점: 데이터 자체가 손상되었거나 형식이 맞지 않는다. (\(context.debugDescription))"
    @unknown default:
        return "알 수 없는 DecodingError: \(decodingError)"
    }
}

[typeMismatch] 'address.zip' 필드: Int 타입을 기대했지만 다른 타입의 값이 왔다. (Expected to decode Int but found a string instead.)
[valueNotFound] 'name' 필드: String 값이 필요한데 null이 왔다. (Cannot get value of type String -- found null value instead)
[keyNotFound] '(최상위)' 아래에 'address' 키가 없다. (No value associated with key CodingKeys(stringValue: "address", intValue: nil) ("address").)
[dataCorrupted] '(최상위)' 지점: 데이터 자체가 손상되었거나 형식이 맞지 않는다. (The given data was not valid JSON.)

import Foundation

protocol Shape {}

struct Circle: Shape, Decodable { let type: String; let radius: Double }
struct Rectangle: Shape, Decodable { let type: String; let width: Double; let height: Double }

// type 키만 얕게 읽기 위한 프로브
private struct TypeProbe: Decodable { let type: String }

// 래퍼: type을 먼저 보고 switch로 알맞은 구체 타입을 다시 디코딩한다
struct ShapeWrapper: Decodable {
    let shape: Shape?     // 관용 모드: 모르는 타입은 nil로 건너뛴다 (배열 전체를 실패시키지 않는다)
    let rawType: String

    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        let probe = try container.decode(TypeProbe.self)
        rawType = probe.type
        switch probe.type {
        case "circle":
            shape = try container.decode(Circle.self)
        case "rectangle":
            shape = try container.decode(Rectangle.self)
        default:
            shape = nil   // 알 수 없는 type -> 이 원소만 건너뛰고 배열 전체는 살린다
        }
    }
}

let json = """
[
  {"type":"circle","radius":2.5},
  {"type":"rectangle","width":3,"height":4},
  {"type":"triangle","base":1,"height":1}
]
"""

let wrappers = try! JSONDecoder().decode([ShapeWrapper].self, from: Data(json.utf8))
for w in wrappers {
    if let shape = w.shape {
        print("디코딩 성공:", type(of: shape), shape)
    } else {
        print("알 수 없는 타입 건너뜀: type=\(w.rawType)")
    }
}

디코딩 성공: Circle Circle(type: "circle", radius: 2.5)
디코딩 성공: Rectangle Rectangle(type: "rectangle", width: 3.0, height: 4.0)
알 수 없는 타입 건너뜀: type=triangle
전체 3개 중 성공 2개

let knownShapes: [Shape] = wrappers.compactMap { $0.shape }
print("표시 가능한 도형", knownShapes.count, "개")

struct StrictShapeWrapper: Decodable {
    let shape: Shape

    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        let probe = try container.decode(TypeProbe.self)
        switch probe.type {
        case "circle":
            shape = try container.decode(Circle.self)
        case "rectangle":
            shape = try container.decode(Rectangle.self)
        default:
            throw DecodingError.dataCorruptedError(
                in: container,
                debugDescription: "알 수 없는 도형 타입: \(probe.type)"
            )
        }
    }
}

import Foundation

let dict: [String: Any] = ["name": "kim", "age": 30]
let data = try JSONEncoder().encode(dict)   // 컴파일 에러

error: type 'Any' cannot conform to 'Encodable' [#ProtocolTypeNonConformance]
    let data = try JSONEncoder().encode(dict)
                                  |- error: type 'Any' cannot conform to 'Encodable'
                                  |- note: only concrete types such as structs, enums and classes can conform to protocols
                                  `- note: requirement from conditional conformance of '[String : Any]' to 'Encodable'

import Foundation

enum JSONValue: Codable {
    case string(String)
    case number(Double)
    case bool(Bool)
    case object([String: JSONValue])
    case array([JSONValue])
    case null

    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        if container.decodeNil() {
            self = .null
        } else if let v = try? container.decode(Bool.self) {
            self = .bool(v)
        } else if let v = try? container.decode(Double.self) {
            self = .number(v)
        } else if let v = try? container.decode(String.self) {
            self = .string(v)
        } else if let v = try? container.decode([String: JSONValue].self) {
            self = .object(v)
        } else if let v = try? container.decode([JSONValue].self) {
            self = .array(v)
        } else {
            throw DecodingError.dataCorruptedError(in: container, debugDescription: "알 수 없는 JSON 값")
        }
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        switch self {
        case .string(let v): try container.encode(v)
        case .number(let v): try container.encode(v)
        case .bool(let v): try container.encode(v)
        case .object(let v): try container.encode(v)
        case .array(let v): try container.encode(v)
        case .null: try container.encodeNil()
        }
    }
}

let json = #"{"name":"kim","age":30,"tags":["swift","ios"],"active":true,"nickname":null}"#
let value = try! JSONDecoder().decode(JSONValue.self, from: Data(json.utf8))
if case let .object(dict) = value {
    print("name:", dict["name"] ?? "nil")       // string("kim")
    print("age:", dict["age"] ?? "nil")         // number(30.0)
    print("tags:", dict["tags"] ?? "nil")       // array([string("swift"), string("ios")])
    print("nickname:", dict["nickname"] ?? "nil") // null
}

let raw = try! JSONSerialization.jsonObject(with: Data(json.utf8)) as! [String: Any]
let name = raw["name"] as? String   // 매번 as? 캐스팅이 필요, 실수하면 nil로 조용히 새어나간다

import Foundation

struct Order: Codable {
    let id: Int
    let customerName: String
    let items: [String]
    let total: Double
    let isPaid: Bool
}

let count = 50_000
var orders: [Order] = []
orders.reserveCapacity(count)
for i in 0..<count {
    orders.append(Order(id: i, customerName: "고객\(i % 1000)",
                         items: ["item\(i % 7)", "item\(i % 11)"],
                         total: Double(i) * 1.5, isPaid: i % 2 == 0))
}
let data = try! JSONEncoder().encode(orders)

let decoder = JSONDecoder()
let clock = ContinuousClock()
let elapsed = clock.measure { _ = try! decoder.decode([Order].self, from: data) }
print(elapsed)

생성된 JSON 크기: 4644 KB, 레코드 50000 건
재사용 디코더로 decode 1회: 0.086121375 seconds
새 디코더로 decode 1회: 0.085992958 seconds
평균(5회): 0.0853305668 seconds

func loadOrders(from data: Data) async throws -> [Order] {
    try await Task.detached(priority: .userInitiated) {
        try JSONDecoder().decode([Order].self, from: data)
    }.value
}
// 호출부(@MainActor)는 await로 받기만 하면 되고, 파싱 자체는 메인 스레드를 막지 않는다

// ❌ 나쁜 예: 일단 Any로 받고 나중에 캐스팅
let raw = try JSONSerialization.jsonObject(with: data) as! [[String: Any]]
let firstId = raw[0]["id"] as? Int   // 매번 캐스팅, 타입 오류가 런타임까지 숨는다

// ✅ 좋은 예: 처음부터 구체 타입으로
let orders = try JSONDecoder().decode([Order].self, from: data)
let firstId = orders[0].id   // 컴파일 타임에 Int로 보장됨