0Pricing
Swift Academy · Aula

Conformidade com Codable

Torne os tipos codificáveis e decodificáveis automaticamente.

Conformidade com Codable é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 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.

O que é Codable

Codable é um alias de tipo para Encodable & Decodable. Quando um tipo está em conformidade com ele, o Swift pode transformar instâncias em dados externos, como JSON, e reconstruí-las — sem necessidade de escrever código de análise manual.

import Foundation

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

print("Book conforms to Codable")

Síntese automática

Se todas as propriedades armazenadas forem, por si só, Codable, o compilador sintetizará a lógica de codificação e decodificação para você. Você só precisa escrever a lista de propriedades — o Swift preenche o restante.

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ção em dados JSON

Um valor Codable pode ser passado a um JSONEncoder, que produz um bloco de dados Data. Converta esses Data em uma String para inspecionar o texto 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ção de dados JSON

O caminho inverso usa JSONDecoder. Informe o tipo de destino e forneça os Data brutos para que ele reconstrua um valor Swift totalmente tipado.

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)

Conversão de ida e volta de um valor

Codificar e depois decodificar deve devolver um valor igual. Essa conversão de ida e volta é uma maneira rápida de confirmar que a conformidade de um tipo com Codable funciona como esperado.

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)

Apenas Encodable

Você pode estar em conformidade com apenas uma das duas partes. Encodable significa que um tipo pode ser escrito, mas não lido de volta — algo útil para modelos de resposta que você nunca precisa analisar.

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

Apenas Decodable

Da mesma forma, Decodable permite construir um tipo a partir de dados externos sem que ele possa ser codificado. Isso é útil para dados de API somente leitura que você apenas consome.

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)

Tipos de propriedades compatíveis

Tipos da biblioteca padrão, como String, Int, Double, Bool, Date, Data e URL, além de arrays e dicionários de elementos Codable, já são Codable por padrão.

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

Enumerações também podem estar em conformidade

Uma enumeração com valores brutos, como String ou Int, torna-se Codable automaticamente. Ela é codificada no JSON como seu valor bruto.

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

Uma propriedade deve ser Codable

A síntese só funciona quando todas as propriedades armazenadas são Codable. Se um tipo personalizado for usado como propriedade, esse tipo também deverá estar em conformidade — caso contrário, o compilador se recusará a sintetizar a implementação.

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

Por que Codable é importante

Codable elimina o código repetitivo de serialização escrito manualmente, mantém o tipo como fonte única da verdade e detecta incompatibilidades no momento da compilação. É a maneira padrão de mover dados para dentro e para fora de aplicativos 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ção rápida: conformidade com Codable

Teste o que você aprendeu sobre conformidade.

Recapitulação: conformidade com Codable

Você aprendeu os fundamentos da serialização em Swift:

  • Codable = Encodable & Decodable.
  • A conformidade é sintetizada quando todas as propriedades são Codable.
  • JSONEncoder produz Data; JSONDecoder reconstrói o valor.
  • Tipos padrão, enumerações com valor bruto e tipos Codable aninhados são todos compatíveis.

Perguntas Frequentes

A aula “Conformidade com Codable” é grátis?

Sim — o texto completo de “Conformidade com Codable” é 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 “Conformidade com Codable”?

Torne os tipos codificáveis e decodificáveis automaticamente. 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 1 de 4.

Quanto tempo leva a aula “Conformidade com Codable”?

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