Swift Academy · Lezione

Conformità a Codable

Rendi automaticamente i tipi codificabili e decodificabili.

Conformità a Codable è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Che cos'è Codable

Codable è un alias di tipo per Encodable & Decodable. Quando un tipo è conforme a questo protocollo, Swift può trasformare le istanze in dati esterni, come JSON, e ricostruirle senza richiedere codice manuale per l'analisi.

import Foundation

struct Book: Codable {
    var title: String
    var pages: Int
}

print("Book conforms to Codable")

Sintesi automatica

Se ogni proprietà memorizzata è a sua volta Codable, il compilatore sintetizza per Lei la logica di codifica e decodifica. Deve soltanto definire l'elenco delle proprietà: Swift si occupa del resto.

import Foundation

struct User: Codable {
    var name: String
    var age: Int
    var isActive: Bool
}

let u = User(name: "Ada", age: 36, isActive: true)
print(u)

Codifica in dati JSON

Un valore Codable può essere passato a un JSONEncoder, che produce un blocco di Data. Converta questi Data in una String per esaminare il testo JSON.

import Foundation

struct User: Codable {
    var name: String
    var age: Int
}

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

Decodifica da dati JSON

Il percorso inverso utilizza JSONDecoder. Gli fornisca il tipo di destinazione e i Data grezzi: ricostruirà un valore Swift completamente tipizzato.

import Foundation

struct User: Codable {
    var name: String
    var age: Int
}

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

Conversione completa di un valore

Codificare e poi decodificare dovrebbe restituire un valore uguale all'originale. Questa conversione completa è un modo rapido per verificare che la conformità Codable di un tipo funzioni come previsto.

import Foundation

struct Point: Codable {
    var x: Int
    var y: Int
}

let p = Point(x: 3, y: 7)
let data = try JSONEncoder().encode(p)
let back = try JSONDecoder().decode(Point.self, from: data)
print(back.x, back.y)

Solo Encodable

È possibile adottare soltanto una delle due parti. Encodable significa che un tipo può essere scritto, ma non letto nuovamente: è utile per i modelli delle risposte che non è necessario analizzare.

import Foundation

struct Receipt: Encodable {
    var item: String
    var total: Double
}

let r = Receipt(item: "Coffee", total: 4.5)
let data = try JSONEncoder().encode(r)
print(String(data: data, encoding: .utf8)!)

Solo Decodable

Analogamente, Decodable consente di creare un tipo a partire da dati esterni senza renderlo codificabile. È utile per i payload di API in sola lettura che si devono soltanto utilizzare.

import Foundation

struct Config: Decodable {
    var version: Int
    var debug: Bool
}

let json = "{\"version\":2,\"debug\":true}"
let data = json.data(using: .utf8)!
let c = try JSONDecoder().decode(Config.self, from: data)
print(c.version, c.debug)

Tipi di proprietà supportati

I tipi della libreria standard come String, Int, Double, Bool, Date, Data, URL, oltre agli array e ai dizionari di elementi Codable, sono tutti Codable automaticamente.

import Foundation

struct Profile: Codable {
    var name: String
    var tags: [String]
    var scores: [String: Int]
}

let p = Profile(name: "Sam", tags: ["a", "b"], scores: ["math": 90])
let data = try JSONEncoder().encode(p)
print(String(data: data, encoding: .utf8)!)

Anche le enumerazioni possono essere conformi

Un'enumerazione con valori grezzi, come String o Int, diventa automaticamente Codable. Nel JSON viene codificata usando il proprio valore grezzo.

import Foundation

enum Status: String, Codable {
    case active, paused, done
}

struct Task: Codable {
    var title: String
    var status: Status
}

let t = Task(title: "Ship", status: .active)
let data = try JSONEncoder().encode(t)
print(String(data: data, encoding: .utf8)!)

Una proprietà deve essere Codable

La sintesi funziona solo quando tutte le proprietà memorizzate sono Codable. Se una proprietà utilizza un tipo personalizzato, anche quel tipo deve essere conforme; in caso contrario, il compilatore non può eseguire la sintesi.

import Foundation

struct Address: Codable {
    var city: String
}

struct Person: Codable {
    var name: String
    var address: Address
}

let p = Person(name: "Lee", address: Address(city: "Rome"))
print(try JSONEncoder().encode(p).count, "bytes")

Perché Codable è importante

Codable elimina il codice ripetitivo scritto manualmente per la serializzazione, mantiene il tipo come unica fonte di verità e rileva le incompatibilità in fase di compilazione. È il modo standard per trasferire dati dentro e fuori dalle app Swift.

import Foundation

struct Settings: Codable {
    var theme: String
    var fontSize: Int
}

let s = Settings(theme: "dark", fontSize: 14)
let data = try JSONEncoder().encode(s)
let back = try JSONDecoder().decode(Settings.self, from: data)
print(back.theme, back.fontSize)

Verifica rapida: conformità a Codable

Verifichi ciò che ha imparato sulla conformità.

Riepilogo: conformità a Codable

Ha appreso le basi della serializzazione in Swift:

Codable = Encodable & Decodable.
La conformità viene sintetizzata quando tutte le proprietà sono Codable.
JSONEncoder produce Data; JSONDecoder ricostruisce il valore.
I tipi standard, le enumerazioni con valore grezzo e i tipi Codable annidati sono tutti supportati.

Domande Frequenti

La lezione «Conformità a Codable» è gratuita?

Sì — il testo completo di «Conformità a Codable» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Conformità a Codable»?

Rendi automaticamente i tipi codificabili e decodificabili. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Conformità a Codable»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Swift Academy