Swift Academy · Lekcja

Obsługa typów optional i zagnieżdżonych

Bezpieczne dekodowanie wartości optional i zagnieżdżonych struktur.

Obsługa typów optional i zagnieżdżonych to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Właściwości opcjonalne

Właściwość opcjonalna jest naturalnie zgodna z Codable, jeśli zgodny jest jej opakowany typ. Brakujący klucz JSON jest dekodowany jako nil, a obecny klucz jest dekodowany w zwykły sposób.

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

Kodowanie opcjonalnych wartości nil

Domyślnie opcjonalna wartość nil jest całkowicie pomijana w zakodowanym JSON, co pozwala uzyskać mniejszy rozmiar danych.

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

Jawna wartość null jest dekodowana jako nil

Jeśli JSON zawiera jawną wartość null dla opcjonalnej właściwości, zostanie ona zdekodowana jako nil, zamiast powodować błąd.

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)

Zagnieżdżone struktury Codable

Modele można tworzyć przez zagnieżdżanie typów Codable. Typ zewnętrzny automatycznie koduje i dekoduje typ wewnętrzny.

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

Dekodowanie zagnieżdżonych struktur

Odwrotny proces również działa: zagnieżdżone obiekty JSON są dekodowane do właściwości zagnieżdżonej struktury.

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)

Opcjonalne typy zagnieżdżone

Zagnieżdżona struktura również może być opcjonalna. Jeśli brakuje klucza, cała zagnieżdżona wartość staje się 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")

Tablice elementów Codable

Tablica elementów typu Codable sama jest zgodna z Codable. Jest bezpośrednio odwzorowywana na tablicę obiektów JSON.

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

Dekodowanie tablic struktur

Dekodowanie tablicy obiektów JSON daje tablicę Swift zawierającą typowane wartości, po której można iterować.

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

Opcjonalne tablice

Opcjonalna tablica rozróżnia sytuację „brak klucza” (nil) od sytuacji „klucz jest obecny, ale tablica jest pusta” ([]). Oba stany są prawidłowe i mają znaczenie.

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

Głęboko zagnieżdżone struktury

Zagnieżdżenie może obejmować kilka poziomów — struktury wewnątrz tablic umieszczonych wewnątrz struktur. Codable obsługuje każdą warstwę rekurencyjnie.

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

Pełny cykl z opcjonalnymi wartościami i zagnieżdżeniami

Połączenie wszystkich elementów: pola opcjonalne, zagnieżdżone struktury i tablice zachowują się poprawnie podczas pełnego cyklu kodowania i dekodowania.

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

Szybkie sprawdzenie: wartości opcjonalne i zagnieżdżenia

Sprawdź swoje rozumienie opcjonalnych i zagnieżdżonych typów Codable.

Podsumowanie: typy opcjonalne i zagnieżdżone

Poznałeś sposób obsługi bardziej złożonych struktur przez Codable:

Właściwości opcjonalne tolerują brakujące klucze i jawną wartość null, dekodując je jako nil.
Opcjonalne wartości nil są domyślnie pomijane podczas kodowania.
Zagnieżdżone struktury i tablice Codable są kodowane i dekodowane rekurencyjnie.
Opcjonalne tablice rozróżniają brak wartości (nil) od pustej tablicy ([]).

Często zadawane pytania

Czy lekcja „Obsługa typów optional i zagnieżdżonych” jest bezpłatna?

Tak — pełny tekst „Obsługa typów optional i zagnieżdżonych” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Obsługa typów optional i zagnieżdżonych”?

Bezpieczne dekodowanie wartości optional i zagnieżdżonych struktur. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Obsługa typów optional i zagnieżdżonych”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Swift Academy