Wann bekomme ich ein `CodingKeys`-Enum?

Sobald ein Eigenschaftsname von seinem Schlüssel abweicht. `content-type` kann kein Name sein, wird also `contentType`, und das Enum bindet ihn zurück: `case contentType = "content-type"`. Wo alle Namen ihren Schlüsseln schon entsprechen, wäre das Enum Lärm und entfällt — Swift erzeugt es selbst.

Was ist dieses `JSONValue`-Enum unten?

Ein kleiner Codable-Typ für die Werte, die die Probe nicht festlegen konnte: `null`, ein leeres Array, ein gemischtes Array. Swift hat kein fertiges „any Codable“, das hin und zurück geht, also zählt das Enum auf, was JSON tragen kann. Es erscheint einmal, nur wenn etwas es braucht, und darf weg, sobald Sie jene Felder durch echte Typen ersetzen.

Sollten die Eigenschaften `let` oder `var` sein?

`let` als Vorgabe, denn eine dekodierte Nutzlast ist ein Wert. Der Schalter stellt das ganze Struct auf `var`, wenn Sie das Objekt bauen statt es zu lesen. Beides zu mischen ist eine Entscheidung je Feld — von Hand zu treffen, sobald das Modell steht.

JSON in Swift — Codable samt fertigen CodingKeys

Ein JSON-Beispiel in Swift-Structs nach Codable verwandeln. Schlüssel, die keine Property-Namen sein können, kommen über fertige CodingKeys zurück.

Sofort Privat Null Cookies

Wurzelname

JSON-Eingabe

Swift-Ausgabe

Was dieses Werkzeug tut

Aus einer JSON-Probe werden Swift-Structs, die Codable erfüllen.

{ "id": 1, "firstName": "Ada", "address": { "city": "Paris" } }

struct Root: Codable {
    let id: Int
    let firstName: String
    let address: Address
}

struct Address: Codable {
    let city: String
}

JSONDecoder liest das direkt. Jedes verschachtelte Objekt bekommt sein Struct; ein Array von Objekten an der Wurzel bekommt einen typealias, damit auch die Liste einen Namen hat.

CodingKeys dort, wo der Name sich ändern musste

Ein Eigenschaftsname trägt keinen Bindestrich, beginnt nicht mit einer Ziffer, und ein Schlüsselwort braucht Backticks. Wenn ein Schlüssel so kein Name sein kann, wird die Zuordnung ausgeschrieben:

struct Root: Codable {
    let contentType: String
    let `class`: Int
    let f2fa: Bool

    enum CodingKeys: String, CodingKey {
        case contentType = "content-type"
        case `class`
        case f2fa = "2fa"
    }
}

Beachten Sie: `class` behält seinen Schlüssel ohne Zuordnung — Backticks ändern, wie Swift den Namen liest, nicht den Namen selbst. Das Enum führt jeden Fall auf, sobald es existiert, denn ein unvollständiges CodingKeys ließe die ausgelassenen Eigenschaften stillschweigend fallen.

`JSONValue`, und warum es da ist

Ein null, ein leeres Array oder ein gemischtes Array lassen nichts zu erschließen. Swift hat keinen fertigen „beliebigen JSON-Wert“, der dekodiert und kodiert, also erscheint einmal am Ende ein kleines Enum:

let nickname: JSONValue?
let tags: [JSONValue]

Es deckt die sechs Dinge ab, die JSON tragen kann, und sonst nichts. Wissen Sie später, dass das Feld eine nullbare Zeichenkette ist, ersetzt String? es, und das Enum darf gehen.

Was eine Probe nicht sagen kann

Nur ein null erzeugt ein Optional. Alles andere ist nicht optional, weil das Dokument einen Wert hatte — ein später ergänztes ? ist ein Zeichen, ein überflüssiges verbirgt ein fehlendes Feld, bis es zählt.

Int und Double kommen aus der Schreibweise der Zahl, nicht aus ihrem Wert: 3 ergibt Int, 3.0 ergibt Double. Der Unterschied zählt in Swift, wo 3.5 in ein Int zu dekodieren wirft, statt zu runden.

Datenschutz ab Werk

Alles läuft lokal in deinem Browser mit JavaScript. Deine Daten werden nie hochgeladen, wodurch das Tool auch für sensible Inhalte sicher ist und offline funktioniert.

Häufige Fragen

Wann bekomme ich ein `CodingKeys`-Enum?: Sobald ein Eigenschaftsname von seinem Schlüssel abweicht. `content-type` kann kein Name sein, wird also `contentType`, und das Enum bindet ihn zurück: `case contentType = "content-type"`. Wo alle Namen ihren Schlüsseln schon entsprechen, wäre das Enum Lärm und entfällt — Swift erzeugt es selbst.
Was ist dieses `JSONValue`-Enum unten?: Ein kleiner Codable-Typ für die Werte, die die Probe nicht festlegen konnte: `null`, ein leeres Array, ein gemischtes Array. Swift hat kein fertiges „any Codable“, das hin und zurück geht, also zählt das Enum auf, was JSON tragen kann. Es erscheint einmal, nur wenn etwas es braucht, und darf weg, sobald Sie jene Felder durch echte Typen ersetzen.
Sollten die Eigenschaften `let` oder `var` sein?: `let` als Vorgabe, denn eine dekodierte Nutzlast ist ein Wert. Der Schalter stellt das ganze Struct auf `var`, wenn Sie das Objekt bauen statt es zu lesen. Beides zu mischen ist eine Entscheidung je Feld — von Hand zu treffen, sobald das Modell steht.