Swift Academy · Lekcja

Strategie dekodowania kluczy i dat

Używanie snake_case oraz strategii dat.

Strategie dekodowania kluczy i dat to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 2 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.

Przegląd strategii dekodowania

Zamiast pisać enumerację CodingKeys dla każdego typu, można ustawić globalną strategię w dekoderze. Strategie przekształcają klucze i jednolicie analizują daty we wszystkich dekodowanych typach.

import Foundation

let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
print("Strategy configured")

convertFromSnakeCase

Ustawienie keyDecodingStrategy = .convertFromSnakeCase automatycznie mapuje klucze takie jak first_name na właściwość camelCase firstName — bez potrzeby używania CodingKeys.

import Foundation

struct User: Codable {
    var firstName: String
    var lastName: String
}

let json = "{\"first_name\":\"Ada\",\"last_name\":\"Lovelace\"}"
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
let u = try decoder.decode(User.self, from: json.data(using: .utf8)!)
print(u.firstName, u.lastName)

Kodowanie do snake_case

Koder ma analogiczną opcję: keyEncodingStrategy = .convertToSnakeCase zapisuje właściwości camelCase jako klucze JSON w formacie snake_case.

import Foundation

struct User: Codable {
    var firstName: String
}

let encoder = JSONEncoder()
encoder.keyEncodingStrategy = .convertToSnakeCase
let data = try encoder.encode(User(firstName: "Ada"))
print(String(data: data, encoding: .utf8)!)

Strategia dotyczy wszystkich kluczy

Strategia kluczy jest stosowana jednolicie do każdej właściwości każdego zagnieżdżonego typu. Jest to idealne rozwiązanie, gdy całe API konsekwentnie używa formatu snake_case.

import Foundation

struct Meta: Codable { var createdAt: String }
struct Doc: Codable { var docTitle: String; var docMeta: Meta }

let json = "{\"doc_title\":\"A\",\"doc_meta\":{\"created_at\":\"now\"}}"
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
let d = try decoder.decode(Doc.self, from: json.data(using: .utf8)!)
print(d.docTitle, d.docMeta.createdAt)

Problem dat

JSON nie ma typu daty. Wartości Date są kodowane jako liczby lub ciągi znaków, dlatego dekoder musi znać ich format. dateDecodingStrategy określa, jak należy je odczytać.

import Foundation

struct Event: Codable {
    var name: String
    var date: Date
}

print("Date needs a strategy to parse")

Dekodowanie dat iso8601

dateDecodingStrategy = .iso8601 analizuje standardowe znaczniki czasu ISO-8601, takie jak 2020-01-01T00:00:00Z, i przekształca je w wartości Date.

import Foundation

struct Event: Codable {
    var name: String
    var date: Date
}

let json = "{\"name\":\"Launch\",\"date\":\"2020-01-01T00:00:00Z\"}"
let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .iso8601
let e = try decoder.decode(Event.self, from: json.data(using: .utf8)!)
print(e.date.timeIntervalSince1970)

Kodowanie dat iso8601

Odpowiednikiem po stronie kodera jest dateEncodingStrategy = .iso8601, który zapisuje wartości Date jako ciągi znaków w formacie ISO-8601.

import Foundation

struct Event: Codable {
    var name: String
    var date: Date
}

let e = Event(name: "Launch", date: Date(timeIntervalSince1970: 1577836800))
let encoder = JSONEncoder()
encoder.dateEncodingStrategy = .iso8601
let data = try encoder.encode(e)
print(String(data: data, encoding: .utf8)!)

Strategia secondsSince1970

Gdy API wysyła znaczniki czasu Unix jako liczby, należy użyć .secondsSince1970, aby zinterpretować je jako liczbę sekund od epoki.

import Foundation

struct Event: Codable {
    var date: Date
}

let json = "{\"date\":1577836800}"
let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .secondsSince1970
let e = try decoder.decode(Event.self, from: json.data(using: .utf8)!)
print(e.date.timeIntervalSince1970)

Niestandardowe formaty dat

W przypadku niestandardowych formatów należy przekazać DateFormatter za pomocą .formatted(_:). Pozwala to obsługiwać daty takie jak 2020-01-01, które nie zawierają składnika czasu.

import Foundation

struct Event: Codable { var date: Date }

let fmt = DateFormatter()
fmt.dateFormat = "yyyy-MM-dd"
fmt.timeZone = TimeZone(identifier: "UTC")
let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .formatted(fmt)
let e = try decoder.decode(Event.self, from: "{\"date\":\"2020-01-01\"}".data(using: .utf8)!)
print(e.date.timeIntervalSince1970)

Łączenie strategii

Strategie kluczy i dat można ustawić jednocześnie na tym samym dekoderze, dzięki czemu można obsłużyć API używające snake_case i ISO-8601 bez powtarzalnego kodu dla poszczególnych typów.

import Foundation

struct LogEntry: Codable {
    var eventName: String
    var occurredAt: Date
}

let json = "{\"event_name\":\"login\",\"occurred_at\":\"2020-01-01T00:00:00Z\"}"
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
decoder.dateDecodingStrategy = .iso8601
let entry = try decoder.decode(LogEntry.self, from: json.data(using: .utf8)!)
print(entry.eventName, entry.occurredAt.timeIntervalSince1970)

Strategia a CodingKeys

Globalna strategia jest zwięzłym rozwiązaniem dla jednolitych API. Gdy tylko kilka kluczy się różni lub nazwy są nieregularne, jawna enumeracja CodingKeys zapewnia precyzyjną kontrolę nad każdym kluczem. Oba rozwiązania można także łączyć.

import Foundation

struct Item: Codable {
    var itemName: String
}

let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
let i = try decoder.decode(Item.self, from: "{\"item_name\":\"Pen\"}".data(using: .utf8)!)
print(i.itemName)

Szybki test: strategie

Proszę sprawdzić zrozumienie strategii dekodowania.

Podsumowanie: strategie kluczy i dat

Poznali Państwo globalną konfigurację kodera:

keyDecodingStrategy = .convertFromSnakeCase mapuje snake_case na camelCase, a .convertToSnakeCase koduje w przeciwnym kierunku.
dateDecodingStrategy = .iso8601 analizuje znaczniki czasu ISO, natomiast .secondsSince1970 i .formatted(_:) obsługują inne formaty.
Strategie są stosowane jednolicie do każdego zagnieżdżonego typu.
Strategii należy używać w przypadku jednolitych API, a CodingKeys w przypadku nieregularnych.

Często zadawane pytania

Czy lekcja „Strategie dekodowania kluczy i dat” jest bezpłatna?

Tak — pełny tekst „Strategie dekodowania kluczy i dat” 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 „Strategie dekodowania kluczy i dat”?

Używanie snake_case oraz strategii dat. Ć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 2 z 4.

Ile czasu zajmuje lekcja „Strategie dekodowania kluczy i dat”?

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