Swift Academy · Lektion

Hantera optionals och nästlade typer

Avkoda optionals och nästlade strukturer på ett säkert sätt.

Lektion 4 av 413 steg

Hantera optionals och nästlade typer är en gratis lektion i Swift Academy på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Swift Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Swift Academy innehåller totalt 4 lektioner.

Optionala egenskaper

En optional egenskap är naturligt Codable när dess inneslutna typ är det. En saknad JSON-nyckel avkodas till nil; en befintlig nyckel avkodas normalt.

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 ?? "-")

Koda nil-optionals

Som standard utelämnas en nil-optional helt från den kodade JSON-datan, vilket ger en mindre nyttolast.

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)!)

Explicit null avkodas till nil

Om JSON innehåller ett explicit null för en optional egenskap avkodas det till nil i stället för att ett fel kastas.

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)

Nästlade Codable-strukturer

Bygg modeller genom att nästla Codable-typer. Den yttre typen kodar och avkodar den inre typen automatiskt.

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)!)

Avkoda nästlade strukturer

Det omvända fungerar också: nästlade JSON-objekt avkodas till egenskaper i den nästlade strukturen.

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)

Optionala nästlade typer

En nästlad struktur kan själv vara optional. Om nyckeln saknas blir hela det nästlade värdet 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")

Arrayer med Codable

En array vars elementtyp är Codable är själv Codable. Den mappas direkt till en JSON-array med objekt.

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)!)

Avkoda arrayer med strukturer

Avkodning av en JSON-array med objekt ger en Swift-array med typade värden som Ni kan iterera över.

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) }

Optionala arrayer

En optional array skiljer mellan "nyckeln saknas" (nil) och "finns men är tom" ([]). Båda är giltiga och meningsfulla tillstånd.

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 == [])

Djupt nästlade strukturer

Nästling kan gå flera nivåer djupt – strukturer inuti arrayer inuti strukturer. Codable hanterar varje lager rekursivt.

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)!)

Rundresa med optionals och nästling

När allt kombineras – optional-fält, nästlade strukturer och arrayer – bevaras allt intakt genom en fullständig kodnings- och avkodningsrundresa.

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 ?? "-")

Snabbtest: Optionals och nästling

Testa Er förståelse av optional och nästlade Codable-typer.

Besvara frågan i den interaktiva lektionen

Sammanfattning: Optionala och nästlade typer

Ni har lärt Er hur Codable hanterar mer komplexa strukturer:

Optionala egenskaper tolererar saknade nycklar och explicit null och avkodas då till nil.
nil-optionals utelämnas som standard vid kodning.
Nästlade Codable-strukturer och arrayer kodas och avkodas rekursivt.
Optionala arrayer skiljer mellan saknade (nil) och tomma ([]) värden.

Gratis att börja

Lär dig Swift med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 122
Lektioner: 409

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Hantera optionals och nästlade typer” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Swift Academy, inklusive ”Hantera optionals och nästlade typer”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Swift Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Hantera optionals och nästlade typer”?

Avkoda optionals och nästlade strukturer på ett säkert sätt. Ni övar på Swift Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Swift Academy?

Du behöver inga förkunskaper. Utbildningen i Swift Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Hantera optionals och nästlade typer”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Swift Academy-lektionen?

Ja. Varje Swift Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Swift Academy