0Pricing
Swift Academy · Lektion

Decodieren mit JSONDecoder

Parsen Sie JSON-Daten in typisierte Swift-Werte.

Decodieren mit JSONDecoder ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Einen JSONDecoder erstellen

JSONDecoder erstellt aus JSON-Data wieder einen Swift-Wert. Sie geben ihm den zu erzeugenden Typ und übergeben ihm die Bytes.

import Foundation

struct City: Codable {
    var name: String
    var population: Int
}

let json = "{\"name\":\"Oslo\",\"population\":700000}"
let data = json.data(using: .utf8)!
let city = try JSONDecoder().decode(City.self, from: data)
print(city.name, city.population)

Den Typ mit .self übergeben

Das erste Argument ist der Metatyp, geschrieben als MyType.self. Damit teilen Sie dem Decoder mit, welche Struktur er aus den Daten erstellen soll.

import Foundation

struct Flag: Codable { var ok: Bool }

let data = "{\"ok\":true}".data(using: .utf8)!
let result = try JSONDecoder().decode(Flag.self, from: data)
print(result.ok)

Arrays dekodieren

Um ein JSON-Array zu dekodieren, fordern Sie einen Array-Typ wie [Int].self oder [MyStruct].self an.

import Foundation

let json = "[10, 20, 30]"
let data = json.data(using: .utf8)!
let numbers = try JSONDecoder().decode([Int].self, from: data)
print(numbers.reduce(0, +))

Verschachtelte Objekte dekodieren

Verschachtelte JSON-Objekte werden auf verschachtelte Codable-Structs abgebildet. Der Decoder durchläuft den Baum und füllt jede Ebene für Sie aus.

import Foundation

struct Coord: Codable { var lat: Double; var lon: Double }
struct Place: Codable { var name: String; var coord: Coord }

let json = "{\"name\":\"X\",\"coord\":{\"lat\":1.0,\"lon\":2.0}}"
let p = try JSONDecoder().decode(Place.self, from: json.data(using: .utf8)!)
print(p.coord.lat, p.coord.lon)

Dekodierungsfehler abfangen

decode löst einen Fehler aus, wenn die Daten nicht zum Typ passen. Schließen Sie den Aufruf in do/catch ein, um fehlerhafte Eingaben angemessen zu behandeln.

import Foundation

struct User: Codable { var name: String }

let bad = "{\"wrong\":1}".data(using: .utf8)!
do {
    let u = try JSONDecoder().decode(User.self, from: bad)
    print(u.name)
} catch {
    print("Failed:", error)
}

keyNotFound-Fehler

Ein häufiger Fehler ist DecodingError.keyNotFound, der ausgelöst wird, wenn ein erforderlicher Schlüssel fehlt. Prüfen Sie den Fehler per Pattern Matching, um genau zu melden, was schiefgelaufen ist.

import Foundation

struct User: Codable { var name: String }

let bad = "{}".data(using: .utf8)!
do {
    _ = try JSONDecoder().decode(User.self, from: bad)
} catch let DecodingError.keyNotFound(key, _) {
    print("Missing key:", key.stringValue)
} catch {
    print("Other error:", error)
}

typeMismatch-Fehler

Wenn ein Wert den falschen JSON-Typ hat – etwa ein String, obwohl ein Int erwartet wird –, löst der Decoder DecodingError.typeMismatch aus.

import Foundation

struct Count: Codable { var n: Int }

let bad = "{\"n\":\"oops\"}".data(using: .utf8)!
do {
    _ = try JSONDecoder().decode(Count.self, from: bad)
} catch let DecodingError.typeMismatch(type, _) {
    print("Type mismatch, expected:", type)
} catch {
    print("Other:", error)
}

dataCorrupted-Fehler

Ungültige JSON-Syntax löst DecodingError.dataCorrupted aus. Das bedeutet normalerweise, dass die Bytes überhaupt kein gültiges JSON enthalten.

import Foundation

struct User: Codable { var name: String }

let bad = "not json".data(using: .utf8)!
do {
    _ = try JSONDecoder().decode(User.self, from: bad)
} catch is DecodingError {
    print("Decoding failed: data corrupted")
} catch {
    print("Other:", error)
}

In Optionals dekodieren

Wenn eine Eigenschaft optional ist, wird ein fehlender Schlüssel ohne Fehler zu nil dekodiert. Dadurch können optionale Felder mit fehlenden Daten umgehen.

import Foundation

struct Profile: Codable {
    var name: String
    var bio: String?
}

let json = "{\"name\":\"Kai\"}"
let p = try JSONDecoder().decode(Profile.self, from: json.data(using: .utf8)!)
print(p.name, p.bio ?? "no bio")

Einen Decoder wiederverwenden

Wie der Encoder kann auch ein konfigurierter JSONDecoder für viele Nutzdaten wiederverwendet werden. Behalten Sie eine Instanz und dekodieren Sie damit verschiedene Eingaben.

import Foundation

struct Word: Codable { var text: String }

let decoder = JSONDecoder()
let inputs = ["{\"text\":\"hi\"}", "{\"text\":\"bye\"}"]
for s in inputs {
    let w = try decoder.decode(Word.self, from: s.data(using: .utf8)!)
    print(w.text)
}

Dekodieren, prüfen, verwenden

Ein vollständiger Ablauf: Empfangen Sie Data, dekodieren Sie es innerhalb von do/catch in einen typisierten Wert und verwenden Sie anschließend das stark typisierte Ergebnis sicher.

import Foundation

struct Weather: Codable {
    var city: String
    var temp: Double
}

let json = "{\"city\":\"Rome\",\"temp\":21.5}"
do {
    let w = try JSONDecoder().decode(Weather.self, from: json.data(using: .utf8)!)
    print("\(w.city): \(w.temp)C")
} catch {
    print("Decode error:", error)
}

Schnelltest: JSONDecoder

Testen Sie Ihr Wissen über das Dekodieren.

Rückblick: Mit JSONDecoder dekodieren

Sie haben gelernt, Swift-Werte aus JSON wiederherzustellen:

  • decode(MyType.self, from: data) erzeugt einen typisierten Wert.
  • Arrays, verschachtelte Objekte und Optionals werden automatisch dekodiert.
  • decode löst Fälle von DecodingError aus: keyNotFound, typeMismatch, dataCorrupted, valueNotFound.
  • Schließen Sie Aufrufe in do/catch ein, um fehlerhafte Eingaben zu behandeln.

Häufig gestellte Fragen

Ist die Lektion „Decodieren mit JSONDecoder“ kostenlos?

Ja — der vollständige Text von „Decodieren mit JSONDecoder“ 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 „Decodieren mit JSONDecoder“?

Parsen Sie JSON-Daten in typisierte Swift-Werte. 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 3 von 4.

Wie lange dauert die Lektion „Decodieren mit JSONDecoder“?

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. Codable-Konformität
  2. Encodieren mit JSONEncoder
  3. Decodieren mit JSONDecoder
  4. Optionale und verschachtelte Typen verarbeiten
← Zurück zu Swift Academy