0Pricing
Swift Academy · Lektion

CodingKeys zum Umbenennen

Ordnen Sie abweichende JSON- und Eigenschaftsnamen einander zu.

CodingKeys zum Umbenennen ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum Schlüssel umbenennen?

JSON-APIs verwenden häufig Namen, die sich von Ihren Swift-Eigenschaftsnamen unterscheiden – first_name statt firstName. Ein CodingKeys-Enum verbindet beide, ohne die API Ihres Modells zu ändern.

import Foundation

struct User: Codable {
    var firstName: String
    enum CodingKeys: String, CodingKey {
        case firstName = "first_name"
    }
}

print("CodingKeys maps firstName to first_name")

Aufbau von CodingKeys

CodingKeys ist ein verschachteltes Enum, das String, CodingKey entspricht. Jeder Case entspricht einem Eigenschaftsnamen; sein Rohwert ist der zu verwendende JSON-Schlüssel.

import Foundation

struct Product: Codable {
    var productName: String
    var unitPrice: Double
    enum CodingKeys: String, CodingKey {
        case productName = "product_name"
        case unitPrice = "unit_price"
    }
}

print(Product.CodingKeys.productName.rawValue)

Mit umbenannten Schlüsseln dekodieren

Beim Dekodieren sucht der Decoder jede Eigenschaft anhand des Rohwerts in CodingKeys, sodass JSON in snake_case Eigenschaften in camelCase befüllt.

import Foundation

struct User: Codable {
    var firstName: String
    enum CodingKeys: String, CodingKey {
        case firstName = "first_name"
    }
}

let json = "{\"first_name\":\"Ada\"}"
let u = try JSONDecoder().decode(User.self, from: json.data(using: .utf8)!)
print(u.firstName)

Mit umbenannten Schlüsseln kodieren

Beim Kodieren wird dieselbe Zuordnung umgekehrt verwendet: Das ausgegebene JSON enthält die Schlüssel aus den Rohwerten, nicht die Swift-Eigenschaftsnamen.

import Foundation

struct User: Codable {
    var firstName: String
    enum CodingKeys: String, CodingKey {
        case firstName = "first_name"
    }
}

let data = try JSONEncoder().encode(User(firstName: "Ada"))
print(String(data: data, encoding: .utf8)!)

Alle Eigenschaften auflisten

Sobald Sie ein CodingKeys-Enum hinzufügen, muss es einen Case für jede Eigenschaft enthalten, die Sie kodieren oder dekodieren möchten. Cases ohne Rohwert verwenden den Eigenschaftsnamen unverändert.

import Foundation

struct Item: Codable {
    var id: Int
    var displayName: String
    enum CodingKeys: String, CodingKey {
        case id
        case displayName = "display_name"
    }
}

let data = try JSONEncoder().encode(Item(id: 1, displayName: "Pen"))
print(String(data: data, encoding: .utf8)!)

Eine Eigenschaft weglassen

Wenn Sie eine Eigenschaft in CodingKeys weglassen, wird sie vom Kodieren und Dekodieren ausgeschlossen. Eine solche Eigenschaft muss einen Standardwert haben, damit der synthetisierte Initialisierer den Typ weiterhin erstellen kann.

import Foundation

struct User: Codable {
    var name: String
    var cachedToken: String = "none"
    enum CodingKeys: String, CodingKey {
        case name
    }
}

let u = try JSONDecoder().decode(User.self, from: "{\"name\":\"Ada\"}".data(using: .utf8)!)
print(u.name, u.cachedToken)

Mehrere Schlüssel umbenennen

Ordnen Sie so viele Schlüssel zu, wie Sie benötigen. Jeder Case verbindet eine Swift-Eigenschaft mit dem genauen JSON-Schlüssel, den der Server erwartet.

import Foundation

struct Account: Codable {
    var userId: Int
    var isVerified: Bool
    enum CodingKeys: String, CodingKey {
        case userId = "user_id"
        case isVerified = "is_verified"
    }
}

let json = "{\"user_id\":7,\"is_verified\":true}"
let a = try JSONDecoder().decode(Account.self, from: json.data(using: .utf8)!)
print(a.userId, a.isVerified)

Benutzerfreundlichere Namen zuordnen

CodingKeys dient nicht nur für snake_case. Verwenden Sie es, um kryptische API-Schlüssel in verständliche Swift-Eigenschaftsnamen umzubenennen.

import Foundation

struct Reading: Codable {
    var temperature: Double
    enum CodingKeys: String, CodingKey {
        case temperature = "t"
    }
}

let json = "{\"t\":19.5}"
let r = try JSONDecoder().decode(Reading.self, from: json.data(using: .utf8)!)
print(r.temperature)

CodingKeys mit verschachtelten Typen

Jeder Codable-Typ hat sein eigenes CodingKeys. Ein verschachteltes Struct kann seine eigenen Schlüssel unabhängig vom übergeordneten Typ umbenennen.

import Foundation

struct Meta: Codable {
    var createdAt: String
    enum CodingKeys: String, CodingKey { case createdAt = "created_at" }
}
struct Doc: Codable { var title: String; var meta: Meta }

let json = "{\"title\":\"A\",\"meta\":{\"created_at\":\"today\"}}"
let d = try JSONDecoder().decode(Doc.self, from: json.data(using: .utf8)!)
print(d.meta.createdAt)

Round-Trip mit umbenannten Schlüsseln

Dieselben CodingKeys steuern beide Richtungen, sodass ein Wert in snake_case kodiert und wieder in denselben Swift-Wert dekodiert wird.

import Foundation

struct User: Codable {
    var firstName: String
    var lastName: String
    enum CodingKeys: String, CodingKey {
        case firstName = "first_name"
        case lastName = "last_name"
    }
}

let u = User(firstName: "Ada", lastName: "Lovelace")
let data = try JSONEncoder().encode(u)
let back = try JSONDecoder().decode(User.self, from: data)
print(back.firstName, back.lastName)

Wann Sie CodingKeys verwenden sollten

Verwenden Sie ein explizites CodingKeys-Enum, wenn einzelne Schlüssel präzise gesteuert werden müssen, wenn sich nur einige Schlüssel unterscheiden oder wenn Sie eine Eigenschaft weglassen müssen. Bei einer API, die durchgängig snake_case verwendet, ist eine Decoding-Strategie möglicherweise einfacher.

import Foundation

struct Event: Codable {
    var eventName: String
    var startTime: String
    enum CodingKeys: String, CodingKey {
        case eventName = "name"
        case startTime = "start_time"
    }
}

let json = "{\"name\":\"Launch\",\"start_time\":\"10:00\"}"
let e = try JSONDecoder().decode(Event.self, from: json.data(using: .utf8)!)
print(e.eventName, e.startTime)

Schnelltest: CodingKeys

Testen Sie Ihr Verständnis der Schlüsselumbenennung.

Rückblick: CodingKeys zum Umbenennen

Sie haben gelernt, Schlüssel präzise zu steuern:

  • Deklarieren Sie enum CodingKeys: String, CodingKey verschachtelt im Typ.
  • Der Rohwert jedes Cases ist der JSON-Schlüssel; die Cases steuern sowohl das Kodieren als auch das Dekodieren.
  • Listen Sie jede Eigenschaft auf, die Sie kodieren möchten; das Weglassen einer Eigenschaft schließt sie aus (sie benötigt einen Standardwert).
  • Verschachtelte Typen haben ihre eigenen unabhängigen CodingKeys.

Häufig gestellte Fragen

Ist die Lektion „CodingKeys zum Umbenennen“ kostenlos?

Ja — der vollständige Text von „CodingKeys zum Umbenennen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „CodingKeys zum Umbenennen“?

Ordnen Sie abweichende JSON- und Eigenschaftsnamen einander zu. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „CodingKeys zum Umbenennen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. CodingKeys zum Umbenennen
  2. Strategien für Schlüssel- und Datumsdecodierung
  3. Manuelles encode(to:) und init(from:)
  4. Heterogenes JSON decodieren
← Zurück zu Swift Academy