PricingLoginStart free
Swift Academy · Lektion

Optionale und verschachtelte Typen verarbeiten

Decodieren Sie Optionals und verschachtelte Strukturen sicher.

Lektion 4 von 413 Schritte

Optionale und verschachtelte Typen verarbeiten ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Optionale Eigenschaften

Eine optionale Eigenschaft ist automatisch Codable, wenn ihr enthaltener Typ es ist. Ein fehlender JSON-Schlüssel wird zu nil dekodiert; ein vorhandener Schlüssel wird normal dekodiert.

import Foundation

struct User: Codable {
    var name: String
    var nickname: String?
}

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

nil-Optionals kodieren

Standardmäßig wird ein optionaler Wert mit nil vollständig aus dem kodierten JSON weggelassen, wodurch die Nutzdaten kleiner werden.

import Foundation

struct User: Codable {
    var name: String
    var nickname: String?
}

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

Explizites null wird zu nil dekodiert

Wenn das JSON für eine optionale Eigenschaft ausdrücklich null enthält, wird es zu nil dekodiert, statt einen Fehler auszulösen.

import Foundation

struct User: Codable {
    var name: String
    var age: Int?
}

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

Verschachtelte Codable-Structs

Stellen Sie Modelle zusammen, indem Sie Codable-Typen verschachteln. Der äußere Typ kodiert und dekodiert den inneren automatisch.

import Foundation

struct Address: Codable { var city: String; var zip: String }
struct Person: Codable { var name: String; var address: Address }

let p = Person(name: "Lee", address: Address(city: "Rome", zip: "00100"))
let data = try JSONEncoder().encode(p)
print(String(data: data, encoding: .utf8)!)

Verschachtelte Structs dekodieren

Der umgekehrte Weg funktioniert ebenfalls: Verschachtelte JSON-Objekte werden in die Eigenschaften des verschachtelten Structs dekodiert.

import Foundation

struct Address: Codable { var city: String }
struct Person: Codable { var name: String; var address: Address }

let json = "{\"name\":\"Lee\",\"address\":{\"city\":\"Rome\"}}"
let p = try JSONDecoder().decode(Person.self, from: json.data(using: .utf8)!)
print(p.address.city)

Optionale verschachtelte Typen

Ein verschachteltes Struct kann selbst optional sein. Wenn der Schlüssel fehlt, wird der gesamte verschachtelte Wert zu nil.

import Foundation

struct Address: Codable { var city: String }
struct Person: Codable { var name: String; var address: Address? }

let json = "{\"name\":\"Lee\"}"
let p = try JSONDecoder().decode(Person.self, from: json.data(using: .utf8)!)
print(p.address?.city ?? "no address")

Arrays aus Codable-Typen

Ein Array eines Codable-Elementtyps ist selbst Codable. Es wird direkt auf ein JSON-Array aus Objekten abgebildet.

import Foundation

struct Tag: Codable { var name: String }
struct Post: Codable { var title: String; var tags: [Tag] }

let p = Post(title: "Hi", tags: [Tag(name: "swift"), Tag(name: "json")])
let data = try JSONEncoder().encode(p)
print(String(data: data, encoding: .utf8)!)

Arrays aus Structs dekodieren

Beim Dekodieren eines JSON-Arrays aus Objekten erhalten Sie ein Swift-Array typisierter Werte, das Sie durchlaufen können.

import Foundation

struct Tag: Codable { var name: String }

let json = "[{\"name\":\"a\"},{\"name\":\"b\"}]"
let tags = try JSONDecoder().decode([Tag].self, from: json.data(using: .utf8)!)
for t in tags { print(t.name) }

Optionale Arrays

Ein optionales Array unterscheidet zwischen "Schlüssel fehlt" (nil) und "vorhanden, aber leer" ([]). Beide Zustände sind gültig und bedeutsam.

import Foundation

struct Box: Codable { var items: [String]? }

let a = try JSONDecoder().decode(Box.self, from: "{}".data(using: .utf8)!)
let b = try JSONDecoder().decode(Box.self, from: "{\"items\":[]}".data(using: .utf8)!)
print(a.items == nil, b.items == [])

Tief verschachtelte Strukturen

Die Verschachtelung kann mehrere Ebenen tief reichen – Structs in Arrays in Structs. Codable verarbeitet jede Ebene rekursiv.

import Foundation

struct Comment: Codable { var text: String }
struct Article: Codable { var title: String; var comments: [Comment] }
struct Feed: Codable { var articles: [Article] }

let feed = Feed(articles: [Article(title: "A", comments: [Comment(text: "hi")])])
let data = try JSONEncoder().encode(feed)
print(String(data: data, encoding: .utf8)!)

Round-Trip mit Optionals und Verschachtelung

Wenn Sie alles kombinieren, bleiben optionale Felder, verschachtelte Structs und Arrays bei einem vollständigen Kodierungs- und Dekodierungs-Round-Trip unverändert erhalten.

import Foundation

struct Address: Codable { var city: String }
struct Person: Codable {
    var name: String
    var address: Address?
    var hobbies: [String]
}

let p = Person(name: "Mo", address: Address(city: "Cairo"), hobbies: ["chess"])
let data = try JSONEncoder().encode(p)
let back = try JSONDecoder().decode(Person.self, from: data)
print(back.address?.city ?? "-", back.hobbies.first ?? "-")

Schnelltest: Optionals und Verschachtelung

Testen Sie Ihr Verständnis von optionalen und verschachtelten Codable-Typen.

Beantworte es in der interaktiven Lektion

Rückblick: Optionale und verschachtelte Typen

Sie haben gelernt, wie Codable komplexere Strukturen verarbeitet:

  • Optionale Eigenschaften tolerieren fehlende Schlüssel und ausdrücklich gesetztes null und werden zu nil dekodiert.
  • Optionals mit nil werden beim Kodieren standardmäßig weggelassen.
  • Verschachtelte Codable-Structs und Arrays werden rekursiv kodiert und dekodiert.
  • Optionale Arrays unterscheiden zwischen fehlend (nil) und leer ([]).
Kostenlos starten

Lerne Swift mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse
122
Lektionen
409
Kostenlos lernenDen vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Optionale und verschachtelte Typen verarbeiten“ kostenlos?

Ja — der vollständige Text von „Optionale und verschachtelte Typen verarbeiten“ 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 „Optionale und verschachtelte Typen verarbeiten“?

Decodieren Sie Optionals und verschachtelte Strukturen sicher. 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 4 von 4.

Wie lange dauert die Lektion „Optionale und verschachtelte Typen verarbeiten“?

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