0Pricing
Swift Academy · Lezione

Gestione di tipi optional e annidati

Decodifichi in sicurezza optional e strutture annidate.

Gestione di tipi optional e annidati è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 4 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.

Proprietà opzionali

Una proprietà opzionale è naturalmente Codable quando lo è il tipo contenuto. Una chiave JSON mancante viene decodificata come nil; una presente viene decodificata normalmente.

import Foundation

struct User: Codable {
    var name: String
    var nickname: String?
}

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

Codifica degli opzionali nil

Per impostazione predefinita, un opzionale nil viene omesso interamente dal JSON codificato, producendo un payload più piccolo.

import Foundation

struct User: Codable {
    var name: String
    var nickname: String?
}

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

Il valore null esplicito viene decodificato come nil

Se il JSON contiene un null esplicito per una proprietà opzionale, questo viene decodificato come nil invece di generare un errore.

import Foundation

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

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

Struct Codable annidate

Componete i modelli annidando tipi Codable. Il tipo esterno codifica e decodifica automaticamente quello interno.

import Foundation

struct Address: Codable { var city: String; var zip: String }
struct Person: Codable { var name: String; var address: Address }

let p = Person(name: "Lee", address: Address(city: "Rome", zip: "00100"))
let data = try JSONEncoder().encode(p)
print(String(data: data, encoding: .utf8)!)

Decodifica delle struct annidate

Vale anche il contrario: gli oggetti JSON annidati vengono decodificati nelle proprietà della struct annidata.

import Foundation

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

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

Tipi annidati opzionali

Una struct annidata può essere a sua volta opzionale. Se la chiave è assente, l'intero valore annidato diventa nil.

import Foundation

struct Address: Codable { var city: String }
struct Person: Codable { var name: String; var address: Address? }

let json = "{\"name\":\"Lee\"}"
let p = try JSONDecoder().decode(Person.self, from: json.data(using: .utf8)!)
print(p.address?.city ?? "no address")

Array di elementi Codable

Un array il cui tipo di elemento è Codable è a sua volta Codable. Corrisponde direttamente a un array JSON di oggetti.

import Foundation

struct Tag: Codable { var name: String }
struct Post: Codable { var title: String; var tags: [Tag] }

let p = Post(title: "Hi", tags: [Tag(name: "swift"), Tag(name: "json")])
let data = try JSONEncoder().encode(p)
print(String(data: data, encoding: .utf8)!)

Decodifica di array di struct

La decodifica di un array JSON di oggetti produce un array Swift di valori tipizzati che è possibile attraversare.

import Foundation

struct Tag: Codable { var name: String }

let json = "[{\"name\":\"a\"},{\"name\":\"b\"}]"
let tags = try JSONDecoder().decode([Tag].self, from: json.data(using: .utf8)!)
for t in tags { print(t.name) }

Array opzionali

Un array opzionale distingue tra "chiave assente" (nil) e "presente ma vuoto" ([]). Entrambi sono stati validi e significativi.

import Foundation

struct Box: Codable { var items: [String]? }

let a = try JSONDecoder().decode(Box.self, from: "{}".data(using: .utf8)!)
let b = try JSONDecoder().decode(Box.self, from: "{\"items\":[]}".data(using: .utf8)!)
print(a.items == nil, b.items == [])

Strutture profondamente annidate

L'annidamento può raggiungere diversi livelli: struct dentro array dentro struct. Codable gestisce ricorsivamente ogni livello.

import Foundation

struct Comment: Codable { var text: String }
struct Article: Codable { var title: String; var comments: [Comment] }
struct Feed: Codable { var articles: [Article] }

let feed = Feed(articles: [Article(title: "A", comments: [Comment(text: "hi")])])
let data = try JSONEncoder().encode(feed)
print(String(data: data, encoding: .utf8)!)

Conversione completa con opzionali e annidamento

Combinando tutti gli elementi, campi opzionali, struct annidate e array superano integri una conversione completa di codifica e decodifica.

import Foundation

struct Address: Codable { var city: String }
struct Person: Codable {
    var name: String
    var address: Address?
    var hobbies: [String]
}

let p = Person(name: "Mo", address: Address(city: "Cairo"), hobbies: ["chess"])
let data = try JSONEncoder().encode(p)
let back = try JSONDecoder().decode(Person.self, from: data)
print(back.address?.city ?? "-", back.hobbies.first ?? "-")

Verifica rapida: opzionali e annidamento

Verifichi la Sua comprensione dei tipi Codable opzionali e annidati.

Riepilogo: tipi opzionali e annidati

Ha imparato come Codable gestisce strutture più articolate:

  • Le proprietà opzionali tollerano chiavi mancanti e null espliciti, che vengono decodificati come nil.
  • Gli opzionali nil vengono omessi per impostazione predefinita durante la codifica.
  • Struct e array Codable annidati vengono codificati e decodificati ricorsivamente.
  • Gli array opzionali distinguono l'assenza (nil) dall'array vuoto ([]).

Domande Frequenti

La lezione «Gestione di tipi optional e annidati» è gratuita?

Sì — il testo completo di «Gestione di tipi optional e annidati» è 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 «Gestione di tipi optional e annidati»?

Decodifichi in sicurezza optional e strutture annidate. 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 4 di 4.

Quanto tempo richiede la lezione «Gestione di tipi optional e annidati»?

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

  1. Conformità a Codable
  2. Codifica con JSONEncoder
  3. Decodifica con JSONDecoder
  4. Gestione di tipi optional e annidati
← Torna a Swift Academy