Nenhum conteúdo ainda
Conversor online gratuito de JSON para Swift. Converta com um clique respostas de API, arquivos de configuração ou JSON de log em declarações de tipo struct/class Swift puras. Sem cadastro, sem upload: geração em tempo real no seu navegador. Perfeito para modelagem rápida em projetos iOS, macOS, watchOS e tvOS.
JSON para Swift é o processo de converter automaticamente dados em formato JSON (objetos ou arrays) em declarações de tipo struct/class Swift. JSON é o padrão de fato para APIs REST, arquivos de configuração e logs de analytics, enquanto Swift é a linguagem de desenvolvimento principal para aplicativos iOS, macOS, watchOS e tvOS, além de ser uma linguagem central para frameworks do lado do servidor como Vapor. No desenvolvimento é frequentemente necessário escrever os tipos Swift correspondentes para JSON retornado por APIs; escrevê-los manualmente consome tempo e é propenso a omitir campos opcionais. O objetivo desta ferramenta é automatizar esse processo.
Esta ferramenta usa quicktype-core para realizar a conversão localmente no navegador. quicktype é um gerador de estruturas multilíngue; esta ferramenta habilita as opções just-types e no-comments para Swift, então a saída são declarações de propriedades struct/class limpas sem anotações de serialização como Codable, Decodable ou Encodable, e sem instruções import ou comentários de cabeçalho. Esses "tipos puros" permitem aos desenvolvedores adicionar protocolos livremente, ajustar o controle de acesso ou modificar convenções de nomenclatura conforme as preferências de frameworks de rede como Alamofire / Moya.
O sistema de tipos do Swift é conhecido por sua segurança. struct é um tipo valor, adequado para representar dados imutáveis; class é um tipo referência, adequado para cenários que requerem estado compartilhado ou herança. Propriedades geradas por esta ferramenta são mapeadas o mais fielmente possível para String, Int, Double, Bool, [T], tipos personalizados, etc. do Swift. Após a geração, desenvolvedores podem alterar certos campos para Optional (?) com base nas necessidades de negócios, adicionar o protocolo Codable aos tipos, ou promover um struct inteiro para class para obter semântica de referência.
O tratamento de objetos aninhados é uma capacidade chave da ferramenta. Quando o JSON contém objetos aninhados, a ferramenta gera recursivamente subtipos independentes; por exemplo, quando Root contém um objeto address, um tipo Address é gerado, e o tipo principal o referencia via var address: Address. Isso evita definições de tipo duplicadas e permite que o autocompletar e a verificação de tipos do Xcode rastreiem corretamente as relações hierárquicas. A regra de nomenclatura coloca a primeira letra do nome do campo em maiúscula; por exemplo, elementos em um array users são nomeados User.
A inferência de tipo de array segue uma estratégia "inferir pelo primeiro elemento". Se os elementos do array são strings é gerado [String]; se inteiros, [Int]; se números de ponto flutuante, [Double]; se objetos, [tipo personalizado]. Arrays vazios [] carecem de amostras, então [Any] ou um tipo de fallback é gerado; após a geração recomenda-se alterá-los para tipos concretos com base no negócio real. Para arrays particularmente grandes ou esparsos, recomenda-se inserir elementos de exemplo reais no JSON fonte para melhorar a precisão da inferência.
O processamento puro no frontend é a vantagem arquitetural central desta ferramenta. Todo o parsing JSON e a geração de código Swift são executados em JavaScript do navegador (incluindo quicktype-core em um Web Worker), independentemente de serviços backend, e nenhum dado é enviado a qualquer servidor. Este design protege dados JSON que podem conter informações sensíveis e garante que a velocidade de conversão seja limitada apenas pelo desempenho do dispositivo local, sem esperar por viagens de rede. É especialmente importante ao processar JSON contendo chaves de API ou campos de negócios não publicados.
Ao contrário de algumas ferramentas online que vinculam forçosamente estratégias de decodificação Codable / CodingKeys / Date, esta ferramenta adere a um princípio de saída mínima: membros da equipe frequentemente têm preferências diferentes sobre protocolos, nomenclatura e controle de acesso, e esta ferramenta deixa as escolhas de protocolos e estratégias aos desenvolvedores para refinamento por projeto. Este fluxo de trabalho "gerar um semiacabado + pós-processamento em nível de projeto" é geralmente mais popular entre engenheiros em equipes de médio e grande porte do que soluções "tudo em um clique".
O uso mais comum em projetos iOS/macOS: adicione Codable aos structs gerados por esta ferramenta, depois obtenha assincronamente com URLSession e decodifique com JSONDecoder.
import Foundation
// 1) Tipo raiz gerado por esta ferramenta (com protocolo Codable adicionado)
struct User: Codable {
let id: Int
let name: String
let email: String
let isActive: Bool
let tags: [String]
}
// 2) Obtenção e decodificação assíncrona URLSession
func fetchUser(id: Int) async throws -> User {
let url = URL(string: "https://api.example.com/users/\(id)")!
let (data, response) = try await URLSession.shared.data(from: url)
guard
let http = response as? HTTPURLResponse,
(200..<300).contains(http.statusCode)
else {
throw URLError(.badServerResponse)
}
return try JSONDecoder().decode(User.self, from: data)
}
// 3) Exemplo de uso (Swift 5.5+ async/await)
Task {
do {
let user = try await fetchUser(id: 42)
print("User: \(user.name), tags: \(user.tags)")
} catch {
print("Failed to decode:", error)
}
}Ao usar Alamofire, você pode usar responseDecodable diretamente para decodificar automaticamente os structs gerados por esta ferramenta em objetos Swift.
import Foundation
import Alamofire
// Tipo gerado por esta ferramenta, utilizável diretamente após adicionar Codable
struct Product: Codable {
let id: Int
let title: String
let price: Double
let inStock: Bool
let images: [String]
}
final class ProductService {
private let session: Session
init(session: Session = .default) {
self.session = session
}
/// responseDecodable estilo Alamofire 5 async/await
func loadProduct(id: Int) async throws -> Product {
let url = "https://api.example.com/products/\(id)"
return try await withCheckedThrowingContinuation { continuation in
session.request(url)
.validate(statusCode: 200..<300)
.responseDecodable(of: Product.self) { response in
switch response.result {
case .success(let product):
continuation.resume(returning: product)
case .failure(let error):
continuation.resume(throwing: error)
}
}
}
}
}
// Exemplo de chamada estilo Moya
// provider.request(.product(id: 1)).map(Product.self)
// let product: Product = try await provider.request(.product(id: 1)).map(Product.self)Em projetos SwiftUI / Combine, você pode usar os structs gerados juntamente com dataTaskPublisher / decode para fluxos de dados reativos.
import Foundation
import Combine
// Tipo raiz gerado por esta ferramenta
struct Article: Codable, Identifiable {
let id: Int
let title: String
let body: String
let publishedAt: Date
}
final class ArticleRepository {
private let session: URLSession
private var cancellables = Set<AnyCancellable>()
init(session: URLSession = .shared) {
self.session = session
}
/// Expor fluxo de dados com Combine
func articlePublisher(id: Int) -> AnyPublisher<Article, Error> {
let url = URL(string: "https://api.example.com/articles/\(id)")!
let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .iso8601
return session.dataTaskPublisher(for: url)
.map(\.data)
.decode(type: Article.self, decoder: decoder)
.receive(on: DispatchQueue.main)
.eraseToAnyPublisher()
}
/// Inscrever-se no SwiftUI ViewModel
func bind(to viewModel: ArticleViewModel, articleId: Int) {
articlePublisher(id: articleId)
.sink(
receiveCompletion: { completion in
if case .failure(let err) = completion {
viewModel.errorMessage = err.localizedDescription
}
},
receiveValue: { article in
viewModel.article = article
}
)
.store(in: &cancellables)
}
}
final class ArticleViewModel: ObservableObject {
@Published var article: Article?
@Published var errorMessage: String?
}Cole seu conteúdo JSON na caixa de entrada à esquerda. Após um debounce de 400ms, a ferramenta chama automaticamente quicktype-core para convertê-lo em código Swift e exibe o resultado no painel direito em tempo real. Você também pode clicar no botão de upload para selecionar um arquivo .json / .txt, ou clicar no botão de exemplo para carregar dados integrados. Após a conclusão da conversão você pode copiar o resultado ou baixá-lo como arquivo .swift em um clique.
Por padrão não. Esta ferramenta usa o modo just-types do quicktype-core, que produz declarações de propriedades struct/class puras sem anotações Codable, Decodable ou Encodable, e sem instruções import. Se você precisar de Codable, basta adicionar : Codable após a geração (ex. struct User: Codable {}), ou escrever sua própria lógica de parsing com JSONDecoder.
Todo JSON válido é suportado: tipos básicos (null, boolean, number, string), arrays unidimensionais ou multidimensionais e objetos aninhados de profundidade arbitrária. A entrada raiz pode ser um objeto JSON ou um array JSON; a ferramenta prioriza objetos e infere arrays pelo seu primeiro elemento. Entradas não suportadas incluem valores especiais JavaScript (funções, Symbol, undefined) e texto não JSON.
A ferramenta gera recursivamente tipos Swift independentes para cada objeto aninhado. A nomenclatura é baseada em uma combinação do nome do tipo pai e do nome do campo; por exemplo, se Root contém um campo address, um subtipo Address é gerado, e o tipo principal o referencia via var address: Address. Isso evita definições de tipo duplicadas e permite que o autocompletar e a verificação de tipos do Xcode rastreiem corretamente as relações hierárquicas.
Sim. Arrays JSON são convertidos automaticamente na forma [T] do Swift. Se os elementos do array são strings, [String] é gerado; se inteiros, [Int]; se números de ponto flutuante, [Double]; se objetos, [tipo personalizado]. Arrays vazios [] não têm elementos de exemplo, então [Any] é gerado por padrão; após a geração recomenda-se alterá-lo manualmente para um tipo concreto como [String] ou [Int].
Valores null em JSON não podem ter seu tipo concreto inferido; a ferramenta pode gerar Any ou um tipo de fallback. Recomenda-se substituir campos com valor null no JSON fonte por valores de exemplo (ex. "field": "" infere String) ou alterá-los manualmente para Optional com base na lógica de negócios (ex. var phone: String?), o que se alinha melhor com a semântica de segurança do sistema de tipos do Swift.
Sim. Clique no botão do nome do tipo (ou entrada de configurações) na barra de ferramentas para alterar o nome do tipo raiz (o padrão é Root ou é inferido dos dados de exemplo). Nomes de subtipos são gerados automaticamente com base no nome raiz e nomes dos campos; a regra de nomenclatura é colocar a primeira letra do nome do campo em maiúscula, ex. users → User, tags → Tag.
A ferramenta detecta automaticamente a validade do JSON; em caso de erro exibe uma mensagem de erro específica à direita e fornece um botão "Reparar JSON". Ao clicar, erros comuns são automaticamente reparados: vírgulas finais, aspas simples substituídas por aspas duplas, aspas faltantes em chaves, remoção de comentários, etc. Após o reparo bem-sucedido você pode continuar convertendo sem corrigir o JSON manualmente.
Executa totalmente no seu navegador. Todo o parsing JSON e a geração de código Swift são feitos localmente via JavaScript do navegador (incluindo quicktype-core em um Web Worker); o JSON que você insere e o código Swift gerado nunca são enviados a qualquer servidor, nem registrados ou armazenados em cache na nuvem. JSON sensível contendo chaves de API, tokens, campos de privacidade do usuário ou estruturas de negócios não publicadas pode ser usado com segurança — fechar a página apaga tudo.
Sim. O código gerado é sintaxe Swift padrão e pode ser copiado diretamente para um arquivo .swift do Xcode, ou salvo como arquivo .swift através do botão "Baixar" e arrastado para seu projeto. Como a saída são declarações de tipo puras, recomenda-se adicionar manualmente protocolos como Codable, Equatable, Identifiable conforme necessário, ou ajustar modificadores de controle de acesso (public / internal / private).
Sim. Quando a entrada raiz é um array JSON, a ferramenta usa o primeiro elemento do array como modelo para gerar um tipo de elemento e emite a definição desse tipo de elemento. Por exemplo, [{"id":1,"name":"A"}] gera um struct chamado Item (ou um nome inferido dos campos) cujos campos são os do primeiro elemento; o tipo principal o referencia via uma propriedade items: [Item], evitando tratar o array diretamente como tipo raiz.
Não há limite de tamanho explícito, mas o navegador ficará mais lento ao fazer parsing e renderizar JSON muito grande. Recomendações: ① Converta JSON de apenas um módulo de negócios por vez; ② Divida níveis de aninhamento profundos e processe separadamente; ③ Para JSON acima de alguns MB você pode usar a versão de linha de comando do quicktype; ④ Dividir o mesmo JSON em vários submódulos e convertê-los separadamente pode reduzir significativamente o uso de memória.
Ambos convertem JSON em definições de tipo para suas respectivas linguagens, mas seu foco difere: JSON para Swift gera declarações de propriedades struct/class para aplicativos nativos iOS/macOS; JSON para TypeScript gera declarações interface/type para verificação de tipos frontend. Se seu projeto tem tanto um cliente iOS quanto um frontend Web, recomenda-se gerar versões Swift e TS a partir do mesmo JSON para garantir consistência de tipos em ambos os lados.
Esta ferramenta gera tipos puros por padrão sem protocolos. Após a geração você só precisa adicionar : Codable após a declaração struct/class, ex. struct User: Codable {}, e JSONDecoder pode usá-lo. Se você quiser Codable por padrão pode fazer fork do quicktype-core e modificar seu renderizador Swift, ou usar a substituição em lote do Xcode para adicionar o protocolo a todos os tipos após a geração.
A primeira visita requer internet para carregar os scripts da ferramenta e recursos do quicktype-core; depois pode funcionar offline a partir do cache do navegador (em um navegador já visitado). Navegadores móveis (iOS Safari, Android Chrome) também funcionam normalmente; a interface usa um design de tela dividida responsivo que muda automaticamente para empilhamento vertical em orientação retrato.
Sim. Após a geração cada tipo Swift é um struct/class independente; a saída da ferramenta é texto simples. Você pode copiar individualmente um único tipo e colá-lo no Xcode, ou usar a refatoração Rename do Xcode para modificar em lote tipos e campos sem afetar outros tipos. Se precisar regenerar todo o grupo de tipos, basta atualizar a página e colar o JSON novamente.
O suporte do quicktype para unions/enums requer dicas de tipo adicionais ou entrada GraphQL/JSON Schema. Inferir enums apenas a partir de amostras JSON é difícil, então esta ferramenta não gera enums por padrão. Se você precisar de enums pode alterar manualmente o struct correspondente para um enum + Codable, ou usar primeiro uma ferramenta JSON para Kotlin/TypeScript para obter tipos enum e depois migrá-los manualmente para Swift.
A caixa de entrada à esquerda está vazia ou contém apenas espaços em branco. Cole conteúdo JSON válido, ou clique em "Exemplo" para carregar um exemplo, ou em "Carregar" para selecionar um arquivo .json / .txt.
O JSON está malformado. Causas comuns: ① vírgula final (ex. {"a":1,}); ② aspas simples usadas em vez de aspas duplas; ③ sintaxe de objeto JS (ex. {key: value}) em vez de JSON (ex. {"key": "value"}); ④ contém comentários JavaScript. Clicar no botão "Reparar JSON" pode reparar automaticamente alguns erros comuns.
Este é o comportamento esperado. Esta ferramenta usa o modo just-types e gera declarações de propriedades struct/class puras. Se precisar de Codable, adicione : Codable aos tipos após a geração (ex. struct User: Codable {}), ou escreva extension User: Codable {} antes de chamar JSONDecoder.
Arrays vazios não têm elementos de exemplo, então a ferramenta gera o tipo de fallback [Any]. Recomenda-se inserir pelo menos um elemento de exemplo no JSON fonte (ex. [1, 2]), excluir o valor de exemplo após a geração e especificar manualmente um tipo concreto; ou mudar diretamente para um tipo mais preciso como [String] / [User] após a geração.
JSON null não pode inferir tipo concreto; a ferramenta pode gerar Any ou um tipo de fallback. Recomenda-se substituir null no JSON fonte por um valor de exemplo representativo (ex. "" ou 0), depois alterar esse campo para Optional (?) ou um tipo concreto após a geração, ex. var phone: String?.
Você pode modificar o nome do tipo raiz na barra de ferramentas; nomes de subtipos são gerados automaticamente com base no nome raiz + nomes dos campos. Se ainda insatisfeito, use a refatoração Rename do Xcode para modificação em lote após a geração (clique direito → Refactor → Rename); Xcode atualizará sincronamente todas as referências.
O navegador fica mais lento ao renderizar JSON muito grande e gerar muitos tipos. Recomenda-se dividir o JSON em vários módulos de negócios independentes e convertê-los separadamente, ou extrair apenas objetos chave que precisam de modelagem; para JSON acima de 10 MB recomendamos a versão de linha de comando do quicktype.
Significa que você adicionou Codable a alguns campos mas não tratou corretamente os tipos Optional / Date / Enum. Correções comuns: ① Altere todos os campos que podem ser null para Optional<T>; ② Personalize a estratégia de datas com JSONDecoder().dateDecodingStrategy = .iso8601; ③ Personalize CodingKeys para alinhar chaves JSON com nomes de propriedades Swift.
Esta ferramenta preserva os nomes originais dos campos JSON por padrão, então campos snake_case são gerados como estão. Se quiser unificar para camelCase você pode renomear em lote usando Rename do Xcode após a geração, ou converter nomes de campos para camelCase em um renderizador quicktype personalizado, depois adicionar mapeamentos CodingKeys para garantir decodificação JSON correta.
Swift recomenda nomes de campo como identificadores ASCII em inglês. Se o JSON fonte contém chaves chinesas (ex. {"姓名": "Alice"}), o var 姓名: String gerado causará erros do compilador Swift em algumas versões anteriores. Recomenda-se alterar as chaves para inglês (ex. name) no JSON fonte, o que está mais em conformidade com os padrões de codificação Swift.
Esta ferramenta gera propriedades var public por padrão para facilitar o pós-processamento. Se quiser let ou controle de acesso (ex. private(set)), você pode modificar em lote usando Refactor do Xcode → Add Access Control, ou substituir var por let usando sed / uma ferramenta de edição de texto após a geração.
Esta ferramenta mapeia strings ISO 8601 para String por padrão; Swift não as converte automaticamente em Date. Você precisa definir dateDecodingStrategy em JSONDecoder, ex. JSONDecoder().dateDecodingStrategy = .iso8601. Se o formato da data não for padrão você também precisará implementar manualmente um DateFormatter ou lógica de parsing personalizada.
A ferramenta nomeia subtipos "colocando a primeira letra do nome do campo em maiúscula". JSON profundamente aninhado pode ter objetos aninhados com o mesmo nome causando conflitos de tipo. Soluções: ① Adicione prefixos de negócios aos campos no JSON fonte; ② Divida o JSON raiz em vários módulos independentes e gere separadamente; ③ Use Rename do Xcode para modificar em lote nomes de tipos em conflito após a geração.
Esta ferramenta gera internal struct por padrão sem um modificador public explícito. Se seu projeto é dividido por módulos e requer acesso entre módulos, você precisa substituir em lote struct por public struct no Xcode, ou adicionar uniformemente a palavra-chave public usando scripts sed/awk após a geração.
A ferramenta infere automaticamente os tipos Swift correspondentes com base na forma dos valores JSON:
| Exemplo de valor JSON | Método de detecção | Tipo Swift gerado | Observações |
|---|---|---|---|
null | value === null | Any? ou Optional concreto | Não é possível inferir tipo concreto; recomenda-se alterar manualmente para Optional<T> após geração |
true / false | typeof value === 'boolean' | Bool | Mapeado diretamente para o tipo Bool do Swift |
42 | typeof value === 'number' && Number.isInteger(value) | Int | Inteiros são mapeados para Int (32/64 bits determinado pela plataforma) |
3.14 | typeof value === 'number' && !Number.isInteger(value) | Double | Números de ponto flutuante são mapeados para Double |
"hello" | typeof value === 'string' | String | Strings são mapeadas para String |
[] (array vazio) | Array.isArray(value) && value.length === 0 | [Any] | Não é possível inferir tipo de elemento; recomenda-se adicionar exemplo ou alterar manualmente para tipo concreto |
["a", "b"] | Array.isArray(value) && typeof value[0] === 'string' | [String] | Array de strings |
[1, 2, 3] | Array.isArray(value) && typeof value[0] === 'number' | [Int] | Array de inteiros |
[1.5, 2.5] | Array.isArray(value) && typeof value[0] === 'number' && !Number.isInteger(value[0]) | [Double] | Array de floats |
[{...}, {...}] | Array.isArray(value) && typeof value[0] === 'object' | [Item] | Array de objetos, elementos são tipos personalizados, nomes inferidos dos nomes dos campos |
{...} (objeto aninhado) | typeof value === 'object' && !Array.isArray(value) | struct / class independente | Gera recursivamente tipos independentes, nomeados com primeira letra do campo em maiúscula |
Generated Swift types can be directly used in different scenarios on Apple platforms/third-party frameworks:
| Use Case | Common Frameworks | Required Protocols/Processing | Typical Code Snippet |
|---|---|---|---|
REST API parsing | URLSession + JSONDecoder | Add Codable to types, maintain struct value semantics | try JSONDecoder().decode(User.self, from: data) |
Simplified HTTP requests | Alamofire | Add Codable to types, pair with responseDecodable | session.request(url).responseDecodable(of: User.self) |
Abstract network layer | Moya | Add Codable to types, Moya auto-deserializes | provider.request(.user(id: 1)).map(User.self) |
Reactive data streams | Combine + JSONDecoder | Add Codable to types, combine with dataTaskPublisher | URLSession.shared.dataTaskPublisher(for: url).decode(type: User.self, decoder: decoder) |
SwiftUI list display | SwiftUI List + Identifiable | Add Identifiable to types for automatic List forEach | List(items) { Text($0.name) } |
Server model definitions | Vapor | Add Codable to types, Vapor auto Content serialization | struct User: Codable, Content { var id: Int; var name: String } |
Local persistence models | SwiftData/Core Data | Add @Model/@NSManaged to generated struct/class | @Model class User { var id: Int; var name: String } |
Cross-platform type sharing | JSON to Swift + JSON to TypeScript combined | Keep Swift and TS field names consistent, pair TS types on TS end | Swift: var name: String / TS: name: string |
Esta ferramenta JSON para Swift executa todas as operações de parsing JSON e geração de tipos Swift totalmente no seu navegador via JavaScript (quicktype-core / Web Worker). Os dados JSON que você insere e o código Swift gerado nunca são enviados a qualquer servidor, nem registrados, armazenados em cache ou na nuvem. JSON sensível contendo campos de API internos, chaves de API, tokens, dados de privacidade do usuário ou estruturas de negócios não publicadas pode ser usado com segurança; todo o conteúdo de entrada e saída é automaticamente apagado da memória quando você fecha ou atualiza a página, sem depender de serviços de rede de terceiros.