Swift Academy · Lekcja

CodingKeys do zmiany nazw

Mapowanie różniących się nazw JSON i właściwości.

Lekcja 1 z 413 kroki

CodingKeys do zmiany nazw to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 1 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.

Dlaczego zmieniać nazwy kluczy

Interfejsy API oparte na JSON często używają nazw różniących się od nazw właściwości Swift — first_name zamiast firstName. Enum CodingKeys łączy te dwa nazewnictwa bez zmieniania API modelu.

import Foundation

struct User: Codable {
    var firstName: String
    enum CodingKeys: String, CodingKey {
        case firstName = "first_name"
    }
}

print("CodingKeys maps firstName to first_name")

Budowa CodingKeys

CodingKeys to zagnieżdżony enum zgodny z String, CodingKey. Każdy przypadek odpowiada nazwie właściwości, a jego wartość surowa jest kluczem JSON, którego należy użyć.

import Foundation

struct Product: Codable {
    var productName: String
    var unitPrice: Double
    enum CodingKeys: String, CodingKey {
        case productName = "product_name"
        case unitPrice = "unit_price"
    }
}

print(Product.CodingKeys.productName.rawValue)

Dekodowanie ze zmienionymi nazwami kluczy

Podczas dekodowania dekoder wyszukuje każdą właściwość za pomocą wartości surowej z CodingKeys, dzięki czemu JSON w notacji snake_case wypełnia właściwości w notacji camelCase.

import Foundation

struct User: Codable {
    var firstName: String
    enum CodingKeys: String, CodingKey {
        case firstName = "first_name"
    }
}

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

Kodowanie ze zmienionymi nazwami kluczy

Kodowanie wykorzystuje to samo mapowanie w odwrotnym kierunku: wynikowy JSON zawiera klucze będące wartościami surowymi, a nie nazwy właściwości Swift.

import Foundation

struct User: Codable {
    var firstName: String
    enum CodingKeys: String, CodingKey {
        case firstName = "first_name"
    }
}

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

Wymienianie wszystkich właściwości

Po dodaniu enuma CodingKeys należy uwzględnić w nim przypadek dla każdej właściwości, która ma być kodowana lub dekodowana. Przypadki bez wartości surowej zachowują nazwę właściwości bez zmian.

import Foundation

struct Item: Codable {
    var id: Int
    var displayName: String
    enum CodingKeys: String, CodingKey {
        case id
        case displayName = "display_name"
    }
}

let data = try JSONEncoder().encode(Item(id: 1, displayName: "Pen"))
print(String(data: data, encoding: .utf8)!)

Pomijanie właściwości

Pominięcie właściwości w CodingKeys wyklucza ją z kodowania i dekodowania. Taka właściwość musi mieć wartość domyślną, aby automatycznie utworzony inicjalizator mógł nadal utworzyć typ.

import Foundation

struct User: Codable {
    var name: String
    var cachedToken: String = "none"
    enum CodingKeys: String, CodingKey {
        case name
    }
}

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

Zmiana nazw wielu kluczy

Można zmapować dowolną liczbę kluczy. Każdy przypadek łączy właściwość Swift z dokładnym kluczem JSON oczekiwanym przez serwer.

import Foundation

struct Account: Codable {
    var userId: Int
    var isVerified: Bool
    enum CodingKeys: String, CodingKey {
        case userId = "user_id"
        case isVerified = "is_verified"
    }
}

let json = "{\"user_id\":7,\"is_verified\":true}"
let a = try JSONDecoder().decode(Account.self, from: json.data(using: .utf8)!)
print(a.userId, a.isVerified)

Mapowanie na przyjaźniejsze nazwy

CodingKeys służy nie tylko do obsługi snake_case. Można go użyć do zamiany niejasnych kluczy API na czytelne nazwy właściwości Swift.

import Foundation

struct Reading: Codable {
    var temperature: Double
    enum CodingKeys: String, CodingKey {
        case temperature = "t"
    }
}

let json = "{\"t\":19.5}"
let r = try JSONDecoder().decode(Reading.self, from: json.data(using: .utf8)!)
print(r.temperature)

CodingKeys z typami zagnieżdżonymi

Każdy typ Codable ma własny CodingKeys. Zagnieżdżona struktura może niezależnie zmieniać nazwy swoich kluczy, bez wpływu na typ nadrzędny.

import Foundation

struct Meta: Codable {
    var createdAt: String
    enum CodingKeys: String, CodingKey { case createdAt = "created_at" }
}
struct Doc: Codable { var title: String; var meta: Meta }

let json = "{\"title\":\"A\",\"meta\":{\"created_at\":\"today\"}}"
let d = try JSONDecoder().decode(Doc.self, from: json.data(using: .utf8)!)
print(d.meta.createdAt)

Pełny cykl ze zmienionymi nazwami kluczy

Ten sam CodingKeys steruje oboma kierunkami, dzięki czemu wartość jest kodowana do snake_case i dekodowana z powrotem do tej samej wartości Swift.

import Foundation

struct User: Codable {
    var firstName: String
    var lastName: String
    enum CodingKeys: String, CodingKey {
        case firstName = "first_name"
        case lastName = "last_name"
    }
}

let u = User(firstName: "Ada", lastName: "Lovelace")
let data = try JSONEncoder().encode(u)
let back = try JSONDecoder().decode(User.self, from: data)
print(back.firstName, back.lastName)

Kiedy używać CodingKeys

Należy użyć jawnego enuma CodingKeys, gdy poszczególne klucze wymagają precyzyjnej kontroli, gdy różnią się tylko niektóre klucze albo gdy trzeba pominąć właściwość. W przypadku API używającego jednolicie snake_case prostsza może być strategia dekodowania.

import Foundation

struct Event: Codable {
    var eventName: String
    var startTime: String
    enum CodingKeys: String, CodingKey {
        case eventName = "name"
        case startTime = "start_time"
    }
}

let json = "{\"name\":\"Launch\",\"start_time\":\"10:00\"}"
let e = try JSONDecoder().decode(Event.self, from: json.data(using: .utf8)!)
print(e.eventName, e.startTime)

Szybkie sprawdzenie: CodingKeys

Sprawdź swoje rozumienie zmiany nazw kluczy.

Odpowiedz w interaktywnej lekcji

Podsumowanie: CodingKeys do zmiany nazw

Poznałeś precyzyjną kontrolę nad kluczami:

Zadeklaruj enum CodingKeys: String, CodingKey zagnieżdżony w typie.
Wartość surowa każdego przypadku jest kluczem JSON; przypadki sterują zarówno kodowaniem, jak i dekodowaniem.
Wymień każdą właściwość, która ma być kodowana; pominięcie właściwości wyklucza ją z procesu i wymaga wartości domyślnej.
Typy zagnieżdżone mają własne, niezależne enume CodingKeys.

Bezpłatny start

Ucz się Swift dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 122
Lekcje: 409

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „CodingKeys do zmiany nazw” jest bezpłatna?

Tak — pełny tekst „CodingKeys do zmiany nazw” 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 „CodingKeys do zmiany nazw”?

Mapowanie różniących się nazw JSON i właściwości. Ć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 1 z 4.

Ile czasu zajmuje lekcja „CodingKeys do zmiany nazw”?

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