PricingLoginStart free
Swift Academy · Aula

Tratamento de Tipos Opcionais e Aninhados

Decodifique opcionais e estruturas aninhadas com segurança.

Aula 4 de 413 etapas

Tratamento de Tipos Opcionais e Aninhados é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Propriedades opcionais

Uma propriedade opcional é naturalmente Codable quando o tipo que ela contém também é. Uma chave JSON ausente é decodificada como nil; uma chave presente é decodificada 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 ?? "-")

Codificando opcionais nil

Por padrão, um opcional nil é totalmente omitido do JSON codificado, produzindo uma carga de dados menor.

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)!)

null explícito é decodificado como nil

Se o JSON contiver um null explícito para uma propriedade opcional, ele será decodificado como nil em vez de lançar um erro.

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)

Estruturas Codable aninhadas

Componha modelos aninhando tipos Codable. O tipo externo codifica e decodifica o tipo interno automaticamente.

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)!)

Decodificando estruturas aninhadas

O caminho inverso também funciona: objetos JSON aninhados são decodificados nas propriedades da estrutura aninhada.

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)

Tipos aninhados opcionais

Uma estrutura aninhada também pode ser opcional. Se a chave estiver ausente, todo o valor aninhado se tornará 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")

Arrays de valores Codable

Um array cujo tipo de elemento é Codable também é Codable. Ele corresponde diretamente a um array JSON de objetos.

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)!)

Decodificando arrays de estruturas

Decodificar um array JSON de objetos produz um array Swift de valores tipados que você pode percorrer.

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) }

Arrays opcionais

Um array opcional distingue entre "chave ausente" (nil) e "presente, mas vazio" ([]). Ambos são estados válidos e significativos.

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 == [])

Estruturas profundamente aninhadas

O aninhamento pode alcançar vários níveis — estruturas dentro de arrays dentro de estruturas. Codable lida recursivamente com cada camada.

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)!)

Conversão de ida e volta com opcionais e aninhamento

Combinando tudo: campos opcionais, estruturas aninhadas e arrays permanecem intactos após uma conversão completa de ida e volta de codificação e decodificação.

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ção rápida: opcionais e aninhamento

Teste sua compreensão sobre tipos Codable opcionais e aninhados.

Responda na aula interativa

Recapitulação: tipos opcionais e aninhados

Você aprendeu como Codable lida com estruturas mais complexas:

  • Propriedades opcionais toleram chaves ausentes e null explícitos, sendo decodificadas como nil.
  • Opcionais nil são omitidos durante a codificação por padrão.
  • Estruturas e arrays Codable aninhados são codificados e decodificados recursivamente.
  • Arrays opcionais distinguem um valor ausente (nil) de um vazio ([]).
Grátis para começar

Aprenda Swift com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
122
Aulas
409
Começar a aprender grátisVer o curso completo

Perguntas Frequentes

A aula “Tratamento de Tipos Opcionais e Aninhados” é grátis?

Sim — o texto completo de “Tratamento de Tipos Opcionais e Aninhados” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Tratamento de Tipos Opcionais e Aninhados”?

Decodifique opcionais e estruturas aninhadas com segurança. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Tratamento de Tipos Opcionais e Aninhados”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Conformidade com Codable
  2. Codificação com JSONEncoder
  3. Decodificação com JSONDecoder
  4. Tratamento de Tipos Opcionais e Aninhados
← Voltar para Swift Academy