Sense contingut
Convertidor gratuït en línia de JSON a Swift. Convertiu amb un clic respostes d'API, fitxers de configuració o JSON de registre en declaracions de tipus struct/class Swift pures. Sense registre, sense càrrega: generació en temps real al vostre navegador. Perfecte per al modelatge ràpid en projectes iOS, macOS, watchOS i tvOS.
JSON a Swift és el procés de convertir automàticament dades en format JSON (objectes o matrius) en declaracions de tipus struct/class Swift. JSON és l'estàndard de facto per a APIs REST, fitxers de configuració i registres d'analítiques, mentre que Swift és el llenguatge de desenvolupament principal per a aplicacions iOS, macOS, watchOS i tvOS, a més de ser un llenguatge central per a frameworks del costat del servidor com Vapor. En el desenvolupament sovint cal escriure els tipus Swift corresponents per a JSON retornat per APIs; escriure'ls manualment consumeix temps i és propens a ometre camps opcionals. L'objectiu d'aquesta eina és automatitzar aquest procés.
Aquesta eina utilitza quicktype-core per realitzar la conversió localment al navegador. quicktype és un generador d'estructures multilingüe; aquesta eina habilita les opcions just-types i no-comments per a Swift, per tant la sortida són declaracions de propietats struct/class netes sense anotacions de serialització com Codable, Decodable o Encodable, i sense instruccions import o comentaris de capçalera. Aquests "tipus purs" permeten als desenvolupadors afegir protocols lliurement, ajustar el control d'accés o modificar convencions de nomenclatura segons les preferències de frameworks de xarxa com Alamofire / Moya.
El sistema de tipus de Swift és conegut per la seva seguretat. struct és un tipus valor, adequat per representar dades immutables; class és un tipus referència, adequat per a escenaris que requereixen estat compartit o herència. Les propietats generades per aquesta eina s'assignen el més fidelment possible a String, Int, Double, Bool, [T], tipus personalitzats, etc. de Swift. Després de la generació, els desenvolupadors poden canviar certs camps a Optional (?) segons les necessitats de negoci, afegir el protocol Codable als tipus, o promoure un struct sencer a class per obtenir semàntica de referència.
El tractament d'objectes imbricats és una capacitat clau de l'eina. Quan el JSON conté objectes imbricats, l'eina genera recursivament subtipus independents; per exemple, quan Root conté un objecte address, es genera un tipus Address i el tipus principal hi fa referència mitjançant var address: Address. Això evita definicions de tipus duplicades i permet que l'autocomplete i la comprovació de tipus de Xcode segueixin correctament les relacions jeràrquiques. La regla de nomenclatura posa la primera lletra del nom del camp en majúscules; per exemple, elements en una matriu users s'anomenen User.
La inferència de tipus de matriu segueix una estratègia "inferir pel primer element". Si els elements de la matriu són cadenes es genera [String]; si enters, [Int]; si nombres de coma flotant, [Double]; si objectes, [tipus personalitzat]. Les matrius buides [] no tenen mostres, per tant es genera [Any] o un tipus de reserva; després de la generació es recomana canviar-les per tipus concrets segons el negoci real. Per a matrius particularment grans o disperses, es recomana inserir elements d'exemple reals al JSON font per millorar la precisió de la inferència.
El processament pur al frontend és l'avantatge arquitectònic central d'aquesta eina. Tota l'anàlisi JSON i la generació de codi Swift s'executen en JavaScript del navegador (incloent quicktype-core en un Web Worker), independentment de serveis backend, i cap dada s'envia a cap servidor. Aquest disseny protegeix dades JSON que poden contenir informació sensible i garanteix que la velocitat de conversió només estigui limitada pel rendiment del dispositiu local, sense esperar viatges de xarxa. És especialment important en processar JSON que contingui claus d'API o camps de negoci no publicats.
A diferència d'algunes eines en línia que vinculen forçosament estratègies de descodificació Codable / CodingKeys / Date, aquesta eina s'adhereix a un principi de sortida mínima: els membres de l'equip sovint tenen preferències diferents sobre protocols, nomenclatura i control d'accés, i aquesta eina deixa les opcions de protocols i estratègies als desenvolupadors per al refinament per projecte. Aquest flux de treball "generar un semielaborat + postprocessament a nivell de projecte" és generalment més popular entre enginyers en equips mitjans i grans que solucions "tot en un clic".
L'ús més comú en projectes iOS/macOS: afegiu Codable als structs generats per aquesta eina, després obteniu asíncronament amb URLSession i descodifiqueu amb JSONDecoder.
import Foundation
// 1) Tipus arrel generat per aquesta eina (amb protocol Codable afegit)
struct User: Codable {
let id: Int
let name: String
let email: String
let isActive: Bool
let tags: [String]
}
// 2) Obtenció i descodificació así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) Exemple d'ús (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)
}
}En utilitzar Alamofire, podeu utilitzar responseDecodable directament per descodificar automàticament els structs generats per aquesta eina en objectes Swift.
import Foundation
import Alamofire
// Tipus generat per aquesta eina, utilitzable directament després d'afegir 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 estil 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)
}
}
}
}
}
// Exemple de crida estil Moya
// provider.request(.product(id: 1)).map(Product.self)
// let product: Product = try await provider.request(.product(id: 1)).map(Product.self)En projectes SwiftUI / Combine, podeu utilitzar els structs generats juntament amb dataTaskPublisher / decode per a fluxos de dades reactives.
import Foundation
import Combine
// Tipus arrel generat per aquesta eina
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
}
/// Exposar flux de dades amb 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()
}
/// Subscriure's al 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?
}Enganxeu el contingut JSON al quadre d'entrada de l'esquerra. Després d'un debounce de 400 ms, l'eina crida automàticament quicktype-core per convertir-lo en codi Swift i mostra el resultat en temps real al panell dret. També podeu fer clic al botó de càrrega per seleccionar un fitxer .json / .txt, o fer clic al botó d'exemple per carregar dades integrades. Un cop completada la conversió podeu copiar el resultat o descarregar-lo com a fitxer .swift amb un clic.
Per defecte no. Aquesta eina utilitza el mode just-types de quicktype-core, que produeix declaracions de propietats struct/class pures sense anotacions Codable, Decodable o Encodable, i sense instruccions import. Si necessiteu Codable, només cal afegir : Codable després de la generació (ex. struct User: Codable {}), o escriure la vostra pròpia lògica d'anàlisi amb JSONDecoder.
Tot JSON vàlid és admès: tipus bàsics (null, boolean, number, string), matrius unidimensionals o multidimensionals i objectes imbricats de profunditat arbitrària. L'entrada arrel pot ser un objecte JSON o una matriu JSON; l'eina prioritza objectes i infereix matrius pel seu primer element. Les entrades no admeses inclouen valors especials de JavaScript (funcions, Symbol, undefined) i text no JSON.
L'eina genera recursivament tipus Swift independents per a cada objecte imbricat. La nomenclatura es basa en una combinació del nom del tipus pare i els noms dels camps; per exemple, si Root conté un camp address, es genera un subtipus Address i el tipus principal hi fa referència mitjançant var address: Address. Això evita definicions de tipus duplicades i permet que l'autocomplete i la comprovació de tipus de Xcode segueixin correctament les relacions jeràrquiques.
Sí. Les matrius JSON es converteixen automàticament en la forma [T] de Swift. Si els elements de la matriu són cadenes, es genera [String]; si enters, [Int]; si nombres de coma flotant, [Double]; si objectes, [tipus personalitzat]. Les matrius buides [] no tenen elements d'exemple, per tant es genera [Any] per defecte; després de la generació es recomana canviar-les manualment per un tipus concret com [String] o [Int].
Els valors null en JSON no poden inferir el seu tipus concret; l'eina pot generar Any o un tipus de reserva. Es recomana substituir els camps amb valor null en el JSON font per valors d'exemple (ex. "field": "" infereix String) o canviar-los manualment a Optional segons la lògica de negoci (ex. var phone: String?), que s'ajusta millor a la semàntica de seguretat del sistema de tipus de Swift.
Sí. Feu clic al botó del nom del tipus (o entrada de configuracions) a la barra d'eines per canviar el nom del tipus arrel (per defecte és Root o s'infereix de les dades d'exemple). Els noms de subtipus es generen automàticament segons el nom arrel i els noms dels camps; la regla de nomenclatura és posar la primera lletra del nom del camp en majúscules, ex. users → User, tags → Tag.
L'eina detecta automàticament la validesa del JSON; en cas d'error mostra un missatge d'error específic a la dreta i proporciona un botó "Repara JSON". En fer clic, els errors comuns es reparen automàticament: comes finals, cometes simples substituïdes per dobles, cometes que falten a claus, eliminació de comentaris, etc. Després de la reparació amb èxit podeu continuar convertint sense corregir el JSON manualment.
S'executa totalment al vostre navegador. Tota l'anàlisi JSON i la generació de codi Swift es fan localment mitjançant JavaScript del navegador (incloent quicktype-core en un Web Worker); el JSON que introduïu i el codi Swift generat mai s'envien a cap servidor, ni es registren o emmagatzemen en memòria cau al núvol. JSON sensible que contingui claus d'API, testimonis, camps de privadesa de l'usuari o estructures de negoci no publicades es pot utilitzar amb seguretat — tancar la pàgina ho esborra tot.
Sí. El codi generat és sintaxi Swift estàndard i es pot copiar directament a un fitxer .swift de Xcode, o desar-lo com a fitxer .swift mitjançant el botó "Descarrega" i arrossegar-lo al vostre projecte. Com que la sortida són declaracions de tipus pures, es recomana afegir manualment protocols com Codable, Equatable, Identifiable segons calgui, o ajustar modificadors de control d'accés (public / internal / private).
Sí. Quan l'entrada arrel és una matriu JSON, l'eina utilitza el primer element de la matriu com a plantilla per generar un tipus d'element i emet la definició d'aquest tipus d'element. Per exemple, [{"id":1,"name":"A"}] genera un struct anomenat Item (o un nom inferit dels camps) els camps del qual són els del primer element; el tipus principal hi fa referència mitjançant una propietat items: [Item], evitant tractar la matriu directament com a tipus arrel.
No hi ha límit de mida explícit, però el navegador es farà més lent en analitzar i renderitzar JSON molt gran. Recomanacions: ① Convertiu JSON d'un sol mòdul de negoci per vegada; ② Dividiu nivells imbricats profunds i processeu-los separadament; ③ Per a JSON de més d'uns quants MB podeu utilitzar la versió de línia d'ordres de quicktype; ④ Dividir el mateix JSON en diversos submòduls i convertir-los separadament pot reduir significativament l'ús de memòria.
Tots dos converteixen JSON en definicions de tipus per als seus llenguatges respectius, però el seu enfocament difereix: JSON a Swift genera declaracions de propietats struct/class per a aplicacions natives iOS/macOS; JSON a TypeScript genera declaracions interface/type per a la comprovació de tipus del frontend. Si el vostre projecte té tant un client iOS com un frontend web, es recomana generar versions Swift i TS des del mateix JSON per garantir la consistència de tipus a ambdós costats.
Aquesta eina genera tipus purs per defecte sense protocols. Després de la generació només cal afegir : Codable després de la declaració struct/class, ex. struct User: Codable {}, i JSONDecoder el pot utilitzar. Si voleu Codable per defecte podeu fer fork de quicktype-core i modificar el seu renderitzador Swift, o utilitzar la substitució en lots de Xcode per afegir el protocol a tots els tipus després de la generació.
La primera visita requereix internet per carregar els scripts de l'eina i els recursos de quicktype-core; després pot funcionar fora de línia des de la memòria cau del navegador (en un navegador ja visitat). Els navegadors mòbils (iOS Safari, Android Chrome) també funcionen normalment; la interfície utilitza un disseny de pantalla dividida responsiu que canvia automàticament a apilament vertical en orientació retrat.
Sí. Després de la generació cada tipus Swift és un struct/class independent; la sortida de l'eina és text senzill. Podeu copiar individualment un sol tipus i enganxar-lo a Xcode, o utilitzar la refactorització Rename de Xcode per modificar en lots tipus i camps sense afectar altres tipus. Si necessiteu regenerar tot el grup de tipus, només cal actualitzar la pàgina i enganxar el JSON de nou.
El suport de quicktype per a unions/enums requereix indicis de tipus addicionals o entrada GraphQL/JSON Schema. Inferir enums només a partir de mostres JSON és difícil, per tant aquesta eina no genera enums per defecte. Si necessiteu enums podeu canviar manualment l'struct corresponent per un enum + Codable, o utilitzar primer una eina JSON a Kotlin/TypeScript per obtenir tipus enum i després migrar-los manualment a Swift.
El quadre d'entrada de l'esquerra és buit o conté només espais en blanc. Enganxeu contingut JSON vàlid, o feu clic a "Exemple" per carregar un exemple, o a "Carrega" per seleccionar un fitxer .json / .txt.
El JSON està mal format. Causes comunes: ① coma final (ex. {"a":1,}); ② cometes simples utilitzades en lloc de dobles; ③ sintaxi d'objecte JS (ex. {key: value}) en lloc de JSON (ex. {"key": "value"}); ④ conté comentaris JavaScript. Fer clic al botó "Repara JSON" pot reparar automàticament alguns errors comuns.
Aquest és el comportament esperat. Aquesta eina utilitza el mode just-types i genera declaracions de propietats struct/class pures. Si necessiteu Codable, afegiu : Codable als tipus després de la generació (ex. struct User: Codable {}), o escriviu extension User: Codable {} abans de cridar JSONDecoder.
Les matrius buides no tenen elements d'exemple, per tant l'eina genera el tipus de reserva [Any]. Es recomana inserir almenys un element d'exemple al JSON font (ex. [1, 2]), eliminar el valor d'exemple després de la generació i especificar manualment un tipus concret; o canviar directament a un tipus més precís com [String] / [User] després de la generació.
JSON null no pot inferir tipus concret; l'eina pot generar Any o un tipus de reserva. Es recomana substituir null al JSON font per un valor d'exemple representatiu (ex. "" o 0), després canviar aquest camp a Optional (?) o un tipus concret després de la generació, ex. var phone: String?.
Podeu modificar el nom del tipus arrel a la barra d'eines; els noms de subtipus es generen automàticament segons el nom arrel + els noms dels camps. Si encara no esteu satisfets, utilitzeu la refactorització Rename de Xcode per a modificació en lots després de la generació (clic dret → Refactor → Rename); Xcode actualitzarà sincrònicament totes les referències.
El navegador es fa més lent en renderitzar JSON molt gran i generar molts tipus. Es recomana dividir el JSON en diversos mòduls de negoci independents i convertir-los separadament, o extreure només objectes clau que necessiten modelatge; per a JSON de més de 10 MB es recomana la versió de línia d'ordres de quicktype.
Significa que heu afegit Codable a alguns camps però no heu tractat correctament els tipus Optional / Date / Enum. Solucions comunes: ① Canvieu tots els camps que poden ser null a Optional<T>; ② Personalitzeu l'estratègia de dates amb JSONDecoder().dateDecodingStrategy = .iso8601; ③ Personalitzeu CodingKeys per alinear claus JSON amb noms de propietats Swift.
Aquesta eina conserva els noms originals dels camps JSON per defecte, per tant els camps snake_case es generen tal qual. Si voleu unificar a camelCase podeu reanomenar en lots utilitzant Rename de Xcode després de la generació, o convertir els noms dels camps a camelCase en un renderitzador quicktype personalitzat, després afegir mapatges CodingKeys per garantir la descodificació JSON correcta.
Swift recomana noms de camp en anglès ASCII com a identificadors. Si el JSON font conté claus xineses (ex. {"姓名": "Alice"}), el var 姓名: String generat causarà errors del compilador Swift en algunes versions anteriors. Es recomana canviar les claus a anglès (ex. name) al JSON font, que està més en conformitat amb els estàndards de codificació Swift.
Aquesta eina genera propietats var public per defecte per facilitar el postprocessament. Si voleu let o control d'accés (ex. private(set)), podeu modificar en lots utilitzant Refactor de Xcode → Add Access Control, o substituir var per let utilitzant sed / una eina d'edició de text després de la generació.
Aquesta eina assigna cadenes ISO 8601 a String per defecte; Swift no les converteix automàticament a Date. Heu de definir dateDecodingStrategy a JSONDecoder, ex. JSONDecoder().dateDecodingStrategy = .iso8601. Si el format de data no és estàndard també haureu d'implementar manualment un DateFormatter o lògica d'anàlisi personalitzada.
L'eina anomena subtipus "posant la primera lletra del nom del camp en majúscules". El JSON profundament imbricat pot tenir objectes imbricats amb el mateix nom causant conflictes de tipus. Solucions: ① Afegiu prefixos de negoci als camps al JSON font; ② Dividiu el JSON arrel en diversos mòduls independents i genereu separadament; ③ Utilitzeu Rename de Xcode per modificar en lots noms de tipus en conflicte després de la generació.
Aquesta eina genera internal struct per defecte sense un modificador public explícit. Si el vostre projecte està dividit per mòduls i requereix accés entre mòduls, heu de substituir en lots struct per public struct a Xcode, o afegir uniformement la paraula clau public utilitzant scripts sed/awk després de la generació.
L'eina infereix automàticament els tipus Swift corresponents basant-se en la forma dels valors JSON:
| Exemple de valor JSON | Mètode de detecció | Tipus Swift generat | Observacions |
|---|---|---|---|
null | value === null | Any? o Optional concret | No es pot inferir tipus concret; es recomana canviar manualment a Optional<T> després de la generació |
true / false | typeof value === 'boolean' | Bool | Assignat directament al tipus Bool de Swift |
42 | typeof value === 'number' && Number.isInteger(value) | Int | Els enters s'assignen a Int (32/64 bits determinat per la plataforma) |
3.14 | typeof value === 'number' && !Number.isInteger(value) | Double | Els nombres de coma flotant s'assignen a Double |
"hello" | typeof value === 'string' | String | Les cadenes s'assignen a String |
[] (matriu buida) | Array.isArray(value) && value.length === 0 | [Any] | No es pot inferir tipus d'element; es recomana afegir exemple o canviar manualment a tipus concret |
["a", "b"] | Array.isArray(value) && typeof value[0] === 'string' | [String] | Matriu de cadenes |
[1, 2, 3] | Array.isArray(value) && typeof value[0] === 'number' | [Int] | Matriu d'enters |
[1.5, 2.5] | Array.isArray(value) && typeof value[0] === 'number' && !Number.isInteger(value[0]) | [Double] | Matriu de floats |
[{...}, {...}] | Array.isArray(value) && typeof value[0] === 'object' | [Item] | Matriu d'objectes, els elements són tipus personalitzats, els noms s'infereixen dels noms dels camps |
{...} (objecte imbricat) | typeof value === 'object' && !Array.isArray(value) | struct / class independent | Genera recursivament tipus independents, anomenats amb primera lletra del camp en majúscules |
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 |
Aquesta eina JSON a Swift executa totes les operacions d'anàlisi JSON i generació de tipus Swift totalment al vostre navegador mitjançant JavaScript (quicktype-core / Web Worker). Les dades JSON que introduïu i el codi Swift generat mai s'envien a cap servidor, ni es registren, emmagatzemen en memòria cau o al núvol. JSON sensible que contingui camps d'API interns, claus d'API, testimonis, dades de privadesa de l'usuari o estructures de negoci no publicades es pot utilitzar amb seguretat; tot el contingut d'entrada i sortida s'esborra automàticament de la memòria quan tanqueu o refresqueu la pàgina, sense dependre de serveis de xarxa de tercers.