0Pricing
Swift Academy · Aula

Estratégias de Decodificação de Chaves e Datas

Use snake_case e estratégias para datas.

Estratégias de Decodificação de Chaves e Datas é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 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.

Visão geral das estratégias de decodificação

Em vez de escrever uma enumeração CodingKeys para cada tipo, você pode definir uma estratégia global no decodificador. As estratégias transformam chaves e analisam datas uniformemente em todos os tipos decodificados.

import Foundation

let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
print("Strategy configured")

convertFromSnakeCase

Definir keyDecodingStrategy = .convertFromSnakeCase mapeia automaticamente chaves como first_name para a propriedade em camelCase firstName — sem precisar de CodingKeys.

import Foundation

struct User: Codable {
    var firstName: String
    var lastName: String
}

let json = "{\"first_name\":\"Ada\",\"last_name\":\"Lovelace\"}"
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
let u = try decoder.decode(User.self, from: json.data(using: .utf8)!)
print(u.firstName, u.lastName)

Codificação em snake case

O codificador tem a opção correspondente: keyEncodingStrategy = .convertToSnakeCase grava propriedades em camelCase como chaves JSON em snake_case.

import Foundation

struct User: Codable {
    var firstName: String
}

let encoder = JSONEncoder()
encoder.keyEncodingStrategy = .convertToSnakeCase
let data = try encoder.encode(User(firstName: "Ada"))
print(String(data: data, encoding: .utf8)!)

A estratégia se aplica a todas as chaves

Uma estratégia de chaves se aplica uniformemente a todas as propriedades de todos os tipos aninhados. Isso é ideal quando uma API inteira usa snake_case de forma consistente.

import Foundation

struct Meta: Codable { var createdAt: String }
struct Doc: Codable { var docTitle: String; var docMeta: Meta }

let json = "{\"doc_title\":\"A\",\"doc_meta\":{\"created_at\":\"now\"}}"
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
let d = try decoder.decode(Doc.self, from: json.data(using: .utf8)!)
print(d.docTitle, d.docMeta.createdAt)

O problema das datas

JSON não tem um tipo de data. Os valores Date são codificados como números ou strings, e o decodificador precisa conhecer o formato. Uma dateDecodingStrategy informa como fazer isso.

import Foundation

struct Event: Codable {
    var name: String
    var date: Date
}

print("Date needs a strategy to parse")

Decodificação de datas com iso8601

dateDecodingStrategy = .iso8601 analisa marcas de tempo ISO-8601 padrão, como 2020-01-01T00:00:00Z, e as transforma em valores Date.

import Foundation

struct Event: Codable {
    var name: String
    var date: Date
}

let json = "{\"name\":\"Launch\",\"date\":\"2020-01-01T00:00:00Z\"}"
let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .iso8601
let e = try decoder.decode(Event.self, from: json.data(using: .utf8)!)
print(e.date.timeIntervalSince1970)

Codificação de datas com iso8601

A opção correspondente do codificador é dateEncodingStrategy = .iso8601, que grava valores Date como strings no formato ISO-8601.

import Foundation

struct Event: Codable {
    var name: String
    var date: Date
}

let e = Event(name: "Launch", date: Date(timeIntervalSince1970: 1577836800))
let encoder = JSONEncoder()
encoder.dateEncodingStrategy = .iso8601
let data = try encoder.encode(e)
print(String(data: data, encoding: .utf8)!)

Estratégia secondsSince1970

Quando uma API envia marcas de tempo Unix como números, utilize .secondsSince1970 para interpretá-las como segundos desde a época Unix.

import Foundation

struct Event: Codable {
    var date: Date
}

let json = "{\"date\":1577836800}"
let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .secondsSince1970
let e = try decoder.decode(Event.self, from: json.data(using: .utf8)!)
print(e.date.timeIntervalSince1970)

Formatos de data personalizados

Para formatos não padrão, forneça um DateFormatter por meio de .formatted(_:). Isso permite lidar com datas como 2020-01-01 sem um componente de hora.

import Foundation

struct Event: Codable { var date: Date }

let fmt = DateFormatter()
fmt.dateFormat = "yyyy-MM-dd"
fmt.timeZone = TimeZone(identifier: "UTC")
let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .formatted(fmt)
let e = try decoder.decode(Event.self, from: "{\"date\":\"2020-01-01\"}".data(using: .utf8)!)
print(e.date.timeIntervalSince1970)

Combinando estratégias

As estratégias de chaves e datas podem ser definidas juntas no mesmo decodificador, permitindo lidar com uma API em snake_case e ISO-8601 sem código repetitivo por tipo.

import Foundation

struct LogEntry: Codable {
    var eventName: String
    var occurredAt: Date
}

let json = "{\"event_name\":\"login\",\"occurred_at\":\"2020-01-01T00:00:00Z\"}"
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
decoder.dateDecodingStrategy = .iso8601
let entry = try decoder.decode(LogEntry.self, from: json.data(using: .utf8)!)
print(entry.eventName, entry.occurredAt.timeIntervalSince1970)

Estratégia versus CodingKeys

Uma estratégia global é concisa para APIs uniformes. Quando apenas algumas chaves são diferentes ou os nomes são irregulares, uma enumeração CodingKeys explícita oferece controle preciso por chave. Elas podem até ser combinadas.

import Foundation

struct Item: Codable {
    var itemName: String
}

let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
let i = try decoder.decode(Item.self, from: "{\"item_name\":\"Pen\"}".data(using: .utf8)!)
print(i.itemName)

Verificação rápida: estratégias

Teste sua compreensão sobre estratégias de decodificação.

Recapitulação: estratégias de chaves e datas

Você aprendeu a configurar globalmente o codificador:

  • keyDecodingStrategy = .convertFromSnakeCase mapeia snake_case para camelCase; .convertToSnakeCase faz a codificação no sentido inverso.
  • dateDecodingStrategy = .iso8601 analisa marcas de tempo ISO; .secondsSince1970 e .formatted(_:) abrangem outros formatos.
  • As estratégias se aplicam uniformemente a todos os tipos aninhados.
  • Utilize estratégias para APIs uniformes e CodingKeys para APIs irregulares.

Perguntas Frequentes

A aula “Estratégias de Decodificação de Chaves e Datas” é grátis?

Sim — o texto completo de “Estratégias de Decodificação de Chaves e Datas” é 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 “Estratégias de Decodificação de Chaves e Datas”?

Use snake_case e estratégias para datas. 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 2 de 4.

Quanto tempo leva a aula “Estratégias de Decodificação de Chaves e Datas”?

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. CodingKeys para Renomeação
  2. Estratégias de Decodificação de Chaves e Datas
  3. encode(to:) e init(from:) Manuais
  4. Decodificação de JSON Heterogêneo
← Voltar para Swift Academy