Swift Academy · Pelajaran

encode(to:) dan init(from:) Manual

Kendalikan sepenuhnya logika serialisasi.

encode(to:) dan init(from:) Manual adalah pelajaran Swift Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Swift Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Swift Academy mencakup 4 pelajaran total.

Saat Sintesis Tidak Memadai

Terkadang struktur JSON tidak sesuai dengan properti Anda—Anda memerlukan transformasi perhitungan, nilai cadangan bawaan, atau perataan. Dalam hal itu, Anda menerapkan encode(to:) dan init(from:) secara manual.

import Foundation

struct Temperature: Codable {
    var celsius: Double
}

print("Manual coding gives full control")

Mendeklarasikan CodingKeys Terlebih Dahulu

Pengodean manual dimulai dengan enumerasi CodingKeys. Kontainer berkunci menggunakan kunci ini untuk membaca dan menulis nilai.

import Foundation

struct User {
    var name: String
    var age: Int
    enum CodingKeys: String, CodingKey {
        case name
        case age
    }
}

print(User.CodingKeys.name.stringValue)

Menerapkan init(from:)

init(from decoder:) memperoleh kontainer berkunci dengan container(keyedBy:), lalu mendekode setiap properti berdasarkan kuncinya.

import Foundation

struct User: Decodable {
    var name: String
    var age: Int
    enum CodingKeys: String, CodingKey { case name, age }
    init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        name = try c.decode(String.self, forKey: .name)
        age = try c.decode(Int.self, forKey: .age)
    }
}

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

Menerapkan encode(to:)

encode(to encoder:) memperoleh kontainer berkunci yang dapat diubah dengan container(keyedBy:) dan menulis setiap properti menggunakan encode(_:forKey:).

import Foundation

struct User: Encodable {
    var name: String
    var age: Int
    enum CodingKeys: String, CodingKey { case name, age }
    func encode(to encoder: Encoder) throws {
        var c = encoder.container(keyedBy: CodingKeys.self)
        try c.encode(name, forKey: .name)
        try c.encode(age, forKey: .age)
    }
}

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

Codable Lengkap Secara Manual

Menerapkan kedua metode tersebut menjadikan tipe sepenuhnya Codable dengan logika kustom di kedua sisi.

import Foundation

struct Point: Codable {
    var x: Int
    var y: Int
    enum CodingKeys: String, CodingKey { case x, y }
    init(x: Int, y: Int) { self.x = x; self.y = y }
    init(from d: Decoder) throws {
        let c = try d.container(keyedBy: CodingKeys.self)
        x = try c.decode(Int.self, forKey: .x)
        y = try c.decode(Int.self, forKey: .y)
    }
    func encode(to e: Encoder) throws {
        var c = e.container(keyedBy: CodingKeys.self)
        try c.encode(x, forKey: .x)
        try c.encode(y, forKey: .y)
    }
}

let back = try JSONDecoder().decode(Point.self, from: try JSONEncoder().encode(Point(x: 1, y: 2)))
print(back.x, back.y)

Menyediakan Nilai Bawaan

Gunakan decodeIfPresent bersama operator penggabungan nil untuk menyediakan nilai bawaan ketika kunci tidak ada, alih-alih menimbulkan kesalahan.

import Foundation

struct Settings: Decodable {
    var theme: String
    enum CodingKeys: String, CodingKey { case theme }
    init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        theme = try c.decodeIfPresent(String.self, forKey: .theme) ?? "light"
    }
}

let s = try JSONDecoder().decode(Settings.self, from: "{}".data(using: .utf8)!)
print(s.theme)

Mentransformasi Nilai

Dekode manual memungkinkan Anda mentransformasi JSON mentah menjadi representasi yang lebih kaya—di sini, input Fahrenheit disimpan sebagai Celsius.

import Foundation

struct Reading: Decodable {
    var celsius: Double
    enum CodingKeys: String, CodingKey { case fahrenheit }
    init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        let f = try c.decode(Double.self, forKey: .fahrenheit)
        celsius = (f - 32) * 5 / 9
    }
}

let r = try JSONDecoder().decode(Reading.self, from: "{\"fahrenheit\":212}".data(using: .utf8)!)
print(r.celsius)

Meratakan JSON Bertingkat

Anda dapat membaca kontainer bertingkat dengan nestedContainer(keyedBy:forKey:) dan mengangkat nilainya ke struktur Swift yang datar.

import Foundation

struct Profile: Decodable {
    var city: String
    enum Keys: String, CodingKey { case address }
    enum AddressKeys: String, CodingKey { case city }
    init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: Keys.self)
        let a = try c.nestedContainer(keyedBy: AddressKeys.self, forKey: .address)
        city = try a.decode(String.self, forKey: .city)
    }
}

let json = "{\"address\":{\"city\":\"Rome\"}}"
let p = try JSONDecoder().decode(Profile.self, from: json.data(using: .utf8)!)
print(p.city)

Mengen kode ke Kontainer Bertingkat

Enkode dapat melakukan kebalikannya: menulis struktur datar ke dalam objek JSON bertingkat menggunakan nestedContainer(keyedBy:forKey:).

import Foundation

struct Profile: Encodable {
    var city: String
    enum Keys: String, CodingKey { case address }
    enum AddressKeys: String, CodingKey { case city }
    func encode(to encoder: Encoder) throws {
        var c = encoder.container(keyedBy: Keys.self)
        var a = c.nestedContainer(keyedBy: AddressKeys.self, forKey: .address)
        try a.encode(city, forKey: .city)
    }
}

let data = try JSONEncoder().encode(Profile(city: "Rome"))
print(String(data: data, encoding: .utf8)!)

Memvalidasi Saat Dekode

Karena init(from:) hanyalah sebuah penginisialisasi, Anda dapat memvalidasi nilai dan menimbulkan kesalahan kustom ketika nilainya berada di luar rentang.

import Foundation

struct Score: Decodable {
    var value: Int
    enum CodingKeys: String, CodingKey { case value }
    init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        let v = try c.decode(Int.self, forKey: .value)
        guard (0...100).contains(v) else {
            throw DecodingError.dataCorruptedError(forKey: .value, in: c, debugDescription: "out of range")
        }
        value = v
    }
}

let s = try JSONDecoder().decode(Score.self, from: "{\"value\":80}".data(using: .utf8)!)
print(s.value)

Mencampurkan Manual dan Sintesis

Sebuah tipe dapat menerapkan hanya satu metode secara manual dan membiarkan kompiler menyintesis metode lainnya—misalnya init(from:) kustom dengan pengodean hasil sintesis.

import Foundation

struct Flag: Codable {
    var on: Bool
    enum CodingKeys: String, CodingKey { case on }
    init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        on = (try? c.decode(Bool.self, forKey: .on)) ?? false
    }
    init(on: Bool) { self.on = on }
}

let data = try JSONEncoder().encode(Flag(on: true))
print(String(data: data, encoding: .utf8)!)

Pemeriksaan Cepat: Pengodean Manual

Uji pemahaman Anda tentang metode Codable yang ditulis secara manual.

Rangkuman: Manual encode(to:) dan init(from:)

Anda telah mempelajari kendali penuh atas pengodean:

Deklarasikan CodingKeys, lalu terapkan init(from:) dan encode(to:).
Gunakan container(keyedBy:) dan encode/decode(_:forKey:).
decodeIfPresent ditambah ?? menyediakan nilai bawaan; nestedContainer meratakan atau membuat JSON bertingkat.
Anda dapat memvalidasi, mentransformasi, dan mencampurkan metode manual dengan metode hasil sintesis.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “encode(to:) dan init(from:) Manual” gratis?

Ya — teks lengkap “encode(to:) dan init(from:) Manual” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Swift Academy, upgrade ke CoddyKit PRO. Kursus Swift Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “encode(to:) dan init(from:) Manual”?

Kendalikan sepenuhnya logika serialisasi. Kamu berlatih Swift Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Swift Academy?

Tidak diperlukan pengalaman sebelumnya. Swift Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “encode(to:) dan init(from:) Manual” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Swift Academy ini?

Ya. Setiap pelajaran Swift Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Swift Academy