Swift Academy · Lekcja

Dekodowanie za pomocą JSONDecoder

Parsowanie danych JSON do typowanych wartości Swift.

Dekodowanie za pomocą JSONDecoder to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 3 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.

Tworzenie obiektu JSONDecoder

JSONDecoder odtwarza wartość Swift na podstawie danych JSON typu Data. Należy określić typ wynikowy i przekazać mu bajty.

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)

Przekazywanie typu za pomocą .self

Pierwszym argumentem jest metatyp — zapisywany jako MyType.self. Informuje on dekoder, jaką strukturę utworzyć na podstawie danych.

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)

Dekodowanie tablic

Aby zdekodować tablicę JSON, należy zażądać typu tablicowego, takiego jak [Int].self lub [MyStruct].self.

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, +))

Dekodowanie zagnieżdżonych obiektów

Zagnieżdżone obiekty JSON są odwzorowywane na zagnieżdżone struktury Codable. Dekoder przechodzi po całym drzewie i automatycznie wypełnia każdy poziom.

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)

Obsługa błędów dekodowania

decode zgłasza wyjątek, gdy dane nie pasują do typu. Należy umieścić je w bloku do/catch, aby poprawnie obsłużyć nieprawidłowe dane wejściowe.

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

Błędy keyNotFound

Częstym błędem jest DecodingError.keyNotFound, zgłaszany, gdy brakuje wymaganego klucza. Należy dopasować wzorzec błędu, aby dokładnie wskazać przyczynę problemu.

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

Błędy typeMismatch

Jeśli wartość ma nieprawidłowy typ JSON — na przykład w miejscu oczekiwanego Int znajduje się ciąg znaków — dekoder zgłasza błąd DecodingError.typeMismatch.

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

Błędy dataCorrupted

Nieprawidłowa składnia JSON powoduje błąd DecodingError.dataCorrupted. Zwykle oznacza to, że bajty w ogóle nie zawierają prawidłowego JSON.

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

Dekodowanie do wartości opcjonalnych

Jeśli właściwość jest opcjonalna, brakujący klucz zostanie zdekodowany jako nil bez zgłaszania wyjątku. Dzięki temu pola opcjonalne tolerują brak danych.

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

Ponowne używanie obiektu Decoder

Podobnie jak koder, skonfigurowany obiekt JSONDecoder można ponownie wykorzystywać dla wielu danych. Wystarczy zachować jedną instancję i dekodować za jej pomocą różne dane wejściowe.

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

Dekodowanie, sprawdzanie i używanie

Pełny przebieg wygląda następująco: odebranie danych Data, zdekodowanie ich do typowanej wartości wewnątrz bloku do/catch, a następnie bezpieczne użycie silnie typowanego wyniku.

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

Szybkie sprawdzenie: JSONDecoder

Sprawdź swoją wiedzę na temat dekodowania.

Podsumowanie: dekodowanie za pomocą JSONDecoder

Poznałeś sposób odtwarzania wartości Swift na podstawie JSON:

decode(MyType.self, from: data) tworzy typowaną wartość.
Tablice, zagnieżdżone obiekty i wartości opcjonalne są dekodowane automatycznie.
decode zgłasza przypadki DecodingError: keyNotFound, typeMismatch, dataCorrupted i valueNotFound.
Wywołania należy umieszczać w bloku do/catch, aby obsługiwać nieprawidłowe dane wejściowe.

Często zadawane pytania

Czy lekcja „Dekodowanie za pomocą JSONDecoder” jest bezpłatna?

Tak — pełny tekst „Dekodowanie za pomocą JSONDecoder” 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 „Dekodowanie za pomocą JSONDecoder”?

Parsowanie danych JSON do typowanych wartości Swift. Ć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 3 z 4.

Ile czasu zajmuje lekcja „Dekodowanie za pomocą JSONDecoder”?

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