Sin contenido aún
Herramienta online gratuita de JSON a Swift. Convierte respuestas API, archivos de configuración o JSON de registro en declaraciones de tipo struct/class Swift puras con un clic. Sin registro ni subida. Generación en tiempo real en tu navegador. Ideal para modelado rápido en proyectos iOS, macOS, watchOS y tvOS.
JSON a Swift es el proceso de convertir automáticamente datos JSON (objetos o arrays) en declaraciones de tipo struct/class Swift. JSON es el estándar de facto para APIs REST, archivos de configuración y registros, mientras que Swift es el lenguaje principal para iOS, macOS, watchOS y tvOS, además de Vapor. Escribir tipos Swift manualmente para JSON de API consume tiempo y es propenso a errores; esta herramienta automatiza el proceso.
Esta herramienta usa quicktype-core en el navegador para la conversión. quicktype es un generador de estructuras multilingüe; habilitamos las opciones just-types y no-comments para Swift, generando declaraciones limpias sin anotaciones de serialización ni imports. Estos "tipos desnudos" permiten a los desarrolladores añadir protocolos y ajustar el control de acceso libremente.
El sistema de tipos de Swift es conocido por su seguridad. struct es tipo por valor para datos inmutables; class es tipo por referencia para estado compartido o herencia. Las propiedades se mapean a String, Int, Double, Bool, [T], tipos personalizados. Los desarrolladores pueden cambiar campos a Optional (?) o añadir Codable según necesidades.
El manejo de objetos anidados es clave. Se generan subtipos independientes recursivamente (ej., address → Address referenciado como var address: Address). La nomenclatura capitaliza la primera letra de los campos (users → User).
La inferencia de arrays sigue la estrategia "inferir del primer elemento". Arrays vacíos generan [Any]; se recomienda cambiar a tipos concretos. Para arrays grandes o dispersos, poner elementos de muestra reales mejora la precisión.
El procesamiento frontend puro es la ventaja arquitectónica clave. Todo se ejecuta en JavaScript (quicktype-core en Web Worker) sin enviar datos a servidores, protegiendo JSON sensible y garantizando velocidad sin latencia de red.
A diferencia de herramientas que fuerzan Codable/CodingKeys, esta herramienta se adhiere al principio de salida mínima, dejando decisiones de protocolo y estrategia a los desarrolladores. Este flujo de trabajo es popular en equipos medianos y grandes.
Uso más común en iOS/macOS: añade Codable a structs generados y decodifica con JSONDecoder.
import Foundation
struct User: Codable {
let id: Int
let name: String
let email: String
let isActive: Bool
let tags: [String]
}
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)
}
Task {
do {
let user = try await fetchUser(id: 42)
print("User: \(user.name), tags: \(user.tags)")
} catch {
print("Failed to decode:", error)
}
}When using Alamofire, you can directly use responseDecodable to automatically decode structs generated by this tool into Swift objects.
import Foundation
import Alamofire
// Type generated by this tool, directly usable after adding 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
}
/// Alamofire 5 async/await style responseDecodable
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)
}
}
}
}
}
// Moya-style call example
// provider.request(.product(id: 1)).map(Product.self)
// let product: Product = try await provider.request(.product(id: 1)).map(Product.self)In SwiftUI/Combine projects, generated structs can be used with dataTaskPublisher/decode for reactive data streams.
import Foundation
import Combine
// Root type generated by this tool
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
}
/// Expose data stream with 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()
}
/// Subscribe in 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?
}Pega el JSON en el cuadro izquierdo. Tras 400ms de debounce, la herramienta llama a quicktype-core automáticamente y muestra el resultado en el panel derecho. También puedes subir archivos .json/.txt o cargar ejemplos integrados. Tras la conversión, copia con un clic o descarga como .swift.
Por defecto no. Esta herramienta usa el modo just-types de quicktype-core, generando declaraciones de propiedades struct/class puras sin anotaciones Codable, Decodable o Encodable, ni sentencias import. Si necesitas Codable, añade : Codable tras generar (ej., struct User: Codable {}).
Todo JSON válido: tipos básicos (null, boolean, number, string), arrays unidimensionales o multidimensionales y objetos anidados de cualquier profundidad. La entrada raíz puede ser objeto o array; objetos primero, arrays inferidos del primer elemento.
La herramienta genera recursivamente tipos Swift independientes para cada objeto anidado. Si Root contiene un campo address, se genera un subtipo Address referenciado mediante var address: Address. Esto evita definiciones duplicadas y permite a Xcode rastrear correctamente las jerarquías.
Sí. Los arrays JSON se convierten a [T]. Elementos string → [String], enteros → [Int], flotantes → [Double], objetos → [TipoPersonalizado]. Arrays vacíos [] generan [Any]; se recomienda cambiar a tipos concretos tras generar.
Los valores null no pueden tener tipo concreto inferido; se genera Any o tipo de respaldo. Se recomienda reemplazar null por valores de muestra o cambiar manualmente a Optional (ej., var phone: String?).
Sí. Haz clic en el botón de nombre de tipo en la barra de herramientas para modificar el nombre raíz. Los subtipos se generan automáticamente capitalizando la primera letra de los campos (users → User, tags → Tag).
La herramienta detecta errores JSON y muestra un botón "Reparar JSON" que corrige automáticamente: comas finales, comillas simples por dobles, claves sin comillas, comentarios, etc.
Funciona completamente en el navegador local. Todo el procesamiento es mediante JavaScript (quicktype-core en Web Worker); los datos no se suben, registran ni cachean en la nube. JSON sensible puede usarse con seguridad.
Sí. Es sintaxis Swift estándar que se puede copiar o descargar como .swift. Se recomienda añadir protocolos como Codable, Equatable, Identifiable según necesidades del proyecto.
Sí. Si la raíz es un array, se usa el primer elemento como plantilla para generar el tipo de elemento. [{"id":1,"name":"A"}] genera un struct Item referenciado como items: [Item].
No hay límite explícito, pero JSON muy grande ralentiza el navegador. Recomendaciones: convertir un módulo a la vez, dividir anidamiento profundo, usar quicktype CLI para JSON de varios MB.
Ambos convierten JSON a tipos, pero con enfoques diferentes: Swift para apps nativas iOS/macOS, TypeScript para frontend. Proyectos full-stack deberían generar ambas versiones para consistencia.
Añade : Codable tras la declaración struct/class (ej., struct User: Codable {}). Para Codable por defecto, puedes modificar el renderizador Swift de quicktype-core.
Primera visita requiere internet para cargar recursos; después funciona offline desde caché. Navegadores móviles (iOS Safari, Android Chrome) funcionan con diseño responsivo.
Sí. Cada tipo es un struct/class independiente. Puedes copiar tipos individuales o usar Rename en Xcode para refactorizar sin afectar otros tipos.
La inferencia de enums requiere sugerencias de tipo adicionales o entrada GraphQL/JSON Schema. Por defecto no se generan enums; puedes convertir manualmente structs a enum + Codable.
El cuadro de entrada está vacío. Pega JSON válido, carga un ejemplo o sube un archivo.
Formato JSON inválido: coma final, comillas simples en lugar de dobles, sintaxis JS object, o comentarios. Usa "Reparar JSON" para corregir automáticamente.
This is expected behavior. This tool uses just-types mode, outputting pure struct/class property declarations. If you need Codable, add : Codable to types after generation (e.g., struct User: Codable {}), or write extension User: Codable {} before calling JSONDecoder.
Empty arrays have no sample elements; the tool generates fallback type [Any]. It's recommended to put at least one sample element in the source JSON (e.g., [1, 2]), delete the sample value after generation, and manually specify concrete types; or directly change to more precise types like [String]/[User] after generation.
JSON null cannot have concrete type inferred; the tool may generate Any or fallback types. It's recommended to replace null in source JSON with representative sample values (e.g., "" or 0), then change that field to Optional (?) or concrete type after generation, e.g., var phone: String?.
You can modify the root type name in the toolbar; subtype names are automatically generated based on root name + field names. If still unsatisfied, use Xcode Rename refactoring to batch modify after generation (right-click → Refactor → Rename); Xcode will synchronously update all references.
Browser rendering of very large JSON and generating many types will slow down. It's recommended to split JSON into multiple independent business modules for separate conversion, or only extract key objects that need modeling for conversion; for JSON over 10MB, we recommend using the command-line version of quicktype.
This means after adding Codable to some fields, you didn't correctly handle Optional/Date/Enum and other types. Common fixes: ① Change all fields that may be null to Optional<T>; ② Custom date strategy JSONDecoder().dateDecodingStrategy = .iso8601; ③ Custom CodingKeys to align JSON keys with Swift property names.
This tool preserves original JSON field names by default, so snake_case fields are generated as-is. If you want to unify to camelCase, you can batch rename with Xcode Rename after generation, or convert field names to camelCase in a custom quicktype renderer, then add CodingKeys mapping to ensure correct JSON decoding.
Swift recommends English ASCII identifiers for field names. If source JSON contains Chinese keys (e.g., {"姓名": "Alice"}), generated var 姓名: String will cause Swift compiler errors in some historical versions. It's recommended to change keys to English in source JSON (e.g., name), which better conforms to Swift coding standards.
This tool generates var public properties by default for easy post-generation customization. If you need let or access control (like private(set)), you can batch modify using Refactor → Add Access Control in Xcode, or replace var with let using sed/text editing tools after generation.
This tool maps ISO 8601 strings to String by default; Swift does not automatically convert to Date. You need to set dateDecodingStrategy in JSONDecoder, e.g., JSONDecoder().dateDecodingStrategy = .iso8601. If the date format is non-standard, you'll also need to manually implement DateFormatter or custom parsing logic.
The tool uses "capitalize first letter of field name" for subtype naming. In deeply nested JSON, nested objects with the same name can cause type conflicts. Solutions: ① Add business prefixes to fields in source JSON; ② Split root JSON into multiple independent modules for separate generation; ③ Use Xcode Rename to batch modify conflicting type names after generation.
This tool generates internal struct by default without explicit public modifier. If your project is split by module and requires cross-module access, you need to batch replace struct with public struct in Xcode, or uniformly add public keyword using sed/awk scripts after generation.
La herramienta infiere tipos Swift automáticamente según valores JSON:
| Ejemplo JSON | Método detección | Tipo Swift | Notas |
|---|---|---|---|
null | value === null | Any? u Optional | No se puede inferir tipo; cambiar a Optional<T> |
true/false | typeof value === 'boolean' | Bool | Mapeo directo a Bool |
42 | typeof value === 'number' && Number.isInteger(value) | Int | Enteros mapean a Int |
"hello" | typeof value === 'string' | String | Cadenas mapean a String |
"hello" | typeof value === 'string' | String | Strings map to String |
[] (empty array) | Array.isArray(value) && value.length === 0 | [Any] | Cannot infer element type; recommend adding examples or manually changing to concrete types |
["a", "b"] | Array.isArray(value) && typeof value[0] === 'string' | [String] | String array |
[1, 2, 3] | Array.isArray(value) && typeof value[0] === 'number' | [Int] | Integer array |
[1.5, 2.5] | Array.isArray(value) && typeof value[0] === 'number' && !Number.isInteger(value[0]) | [Double] | Float array |
[{...}, {...}] | Array.isArray(value) && typeof value[0] === 'object' | [Item] | Object array, elements are custom types named by field name inference |
{...} (nested object) | typeof value === 'object' && !Array.isArray(value) | Independent struct/class | Recursively generates independent types, named by capitalizing first letter of field names |
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 |
Todas las operaciones de esta herramienta se completan localmente en tu navegador mediante JavaScript (quicktype-core/Web Worker). Los datos JSON y código Swift generado nunca se suben a servidores ni se almacenan en la nube. JSON sensible puede usarse con seguridad; cerrar la página borra todo.