0Pricing
Swift Academy · Aula

Decodificação com JSONDecoder

Converta dados JSON em valores Swift tipados.

Decodificação com JSONDecoder é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 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.

Criando um JSONDecoder

JSONDecoder reconstrói um valor Swift a partir de Data JSON. Informe o tipo que deve ser produzido e forneça os bytes.

import Foundation

struct City: Codable {
    var name: String
    var population: Int
}

let json = "{\"name\":\"Oslo\",\"population\":700000}"
let data = json.data(using: .utf8)!
let city = try JSONDecoder().decode(City.self, from: data)
print(city.name, city.population)

Passando o tipo com .self

O primeiro argumento é o metatipo — escrito como MyType.self. Isso informa ao decodificador qual estrutura deve ser construída a partir dos dados.

import Foundation

struct Flag: Codable { var ok: Bool }

let data = "{\"ok\":true}".data(using: .utf8)!
let result = try JSONDecoder().decode(Flag.self, from: data)
print(result.ok)

Decodificando arrays

Para decodificar um array JSON, solicite um tipo de array, como [Int].self ou [MyStruct].self.

import Foundation

let json = "[10, 20, 30]"
let data = json.data(using: .utf8)!
let numbers = try JSONDecoder().decode([Int].self, from: data)
print(numbers.reduce(0, +))

Decodificando objetos aninhados

Objetos JSON aninhados correspondem a estruturas Codable aninhadas. O decodificador percorre a árvore e preenche cada nível para você.

import Foundation

struct Coord: Codable { var lat: Double; var lon: Double }
struct Place: Codable { var name: String; var coord: Coord }

let json = "{\"name\":\"X\",\"coord\":{\"lat\":1.0,\"lon\":2.0}}"
let p = try JSONDecoder().decode(Place.self, from: json.data(using: .utf8)!)
print(p.coord.lat, p.coord.lon)

Capturando erros de decodificação

decode lança uma exceção quando os dados não correspondem ao tipo. Envolva-o em do/catch para lidar adequadamente com entradas malformadas.

import Foundation

struct User: Codable { var name: String }

let bad = "{\"wrong\":1}".data(using: .utf8)!
do {
    let u = try JSONDecoder().decode(User.self, from: bad)
    print(u.name)
} catch {
    print("Failed:", error)
}

Erros de keyNotFound

Uma falha comum é DecodingError.keyNotFound, lançada quando uma chave obrigatória está ausente. Analise o erro por padrão para informar exatamente o que deu errado.

import Foundation

struct User: Codable { var name: String }

let bad = "{}".data(using: .utf8)!
do {
    _ = try JSONDecoder().decode(User.self, from: bad)
} catch let DecodingError.keyNotFound(key, _) {
    print("Missing key:", key.stringValue)
} catch {
    print("Other error:", error)
}

Erros de typeMismatch

Se um valor tiver o tipo JSON incorreto — por exemplo, uma string onde se espera um Int — o decodificador lançará DecodingError.typeMismatch.

import Foundation

struct Count: Codable { var n: Int }

let bad = "{\"n\":\"oops\"}".data(using: .utf8)!
do {
    _ = try JSONDecoder().decode(Count.self, from: bad)
} catch let DecodingError.typeMismatch(type, _) {
    print("Type mismatch, expected:", type)
} catch {
    print("Other:", error)
}

Erros de dataCorrupted

Uma sintaxe JSON inválida gera DecodingError.dataCorrupted. Isso geralmente significa que os bytes não formam um JSON válido.

import Foundation

struct User: Codable { var name: String }

let bad = "not json".data(using: .utf8)!
do {
    _ = try JSONDecoder().decode(User.self, from: bad)
} catch is DecodingError {
    print("Decoding failed: data corrupted")
} catch {
    print("Other:", error)
}

Decodificando em opcionais

Se uma propriedade for opcional, uma chave ausente será decodificada como nil sem lançar uma exceção. Isso torna os campos opcionais tolerantes à ausência de dados.

import Foundation

struct Profile: Codable {
    var name: String
    var bio: String?
}

let json = "{\"name\":\"Kai\"}"
let p = try JSONDecoder().decode(Profile.self, from: json.data(using: .utf8)!)
print(p.name, p.bio ?? "no bio")

Reutilizando um decodificador

Assim como o codificador, um JSONDecoder configurado pode ser reutilizado para várias cargas de dados. Mantenha uma instância e decodifique diferentes entradas com ela.

import Foundation

struct Word: Codable { var text: String }

let decoder = JSONDecoder()
let inputs = ["{\"text\":\"hi\"}", "{\"text\":\"bye\"}"]
for s in inputs {
    let w = try decoder.decode(Word.self, from: s.data(using: .utf8)!)
    print(w.text)
}

Decodifique, inspecione e use

Um fluxo completo: receba Data, decodifique-o em um valor tipado dentro de do/catch e depois use o resultado fortemente tipado com segurança.

import Foundation

struct Weather: Codable {
    var city: String
    var temp: Double
}

let json = "{\"city\":\"Rome\",\"temp\":21.5}"
do {
    let w = try JSONDecoder().decode(Weather.self, from: json.data(using: .utf8)!)
    print("\(w.city): \(w.temp)C")
} catch {
    print("Decode error:", error)
}

Verificação rápida: JSONDecoder

Teste seus conhecimentos sobre decodificação.

Recapitulação: decodificação com JSONDecoder

Você aprendeu a reconstruir valores Swift a partir de JSON:

  • decode(MyType.self, from: data) produz um valor tipado.
  • Arrays, objetos aninhados e opcionais são decodificados automaticamente.
  • decode lança casos de DecodingError: keyNotFound, typeMismatch, dataCorrupted e valueNotFound.
  • Envolva as chamadas em do/catch para lidar com entradas malformadas.

Perguntas Frequentes

A aula “Decodificação com JSONDecoder” é grátis?

Sim — o texto completo de “Decodificação com JSONDecoder” é 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 “Decodificação com JSONDecoder”?

Converta dados JSON em valores Swift tipados. 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 3 de 4.

Quanto tempo leva a aula “Decodificação com JSONDecoder”?

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