Nessun contenuto
Convertitore online gratuito da JSON a Swift. Converti in un clic risposte API, file di configurazione o JSON di log in dichiarazioni di tipo struct/class Swift pure. Nessuna registrazione, nessun upload: generazione in tempo reale nel tuo browser. Perfetto per la modellazione rapida in progetti iOS, macOS, watchOS e tvOS.
JSON in Swift è il processo di conversione automatica di dati in formato JSON (oggetti o array) in dichiarazioni di tipo struct/class Swift. JSON è lo standard de facto per le API REST, i file di configurazione e i log di analytics, mentre Swift è il linguaggio di sviluppo principale per le applicazioni iOS, macOS, watchOS e tvOS, nonché un linguaggio chiave per framework lato server come Vapor. Nello sviluppo è spesso necessario scrivere i tipi Swift corrispondenti per il JSON restituito dalle API; scriverli a mano richiede tempo ed è soggetto a dimenticare campi opzionali. Lo scopo di questo strumento è automatizzare questo processo.
Questo strumento utilizza quicktype-core per completare la conversione localmente nel browser. quicktype è un generatore di strutture multilingua; questo strumento abilita le opzioni just-types e no-comments per Swift, quindi l'output sono dichiarazioni di proprietà struct/class pulite senza annotazioni di serializzazione come Codable, Decodable o Encodable, e senza istruzioni import o commenti di intestazione. Questi "tipi nudi" consentono agli sviluppatori di aggiungere liberamente protocolli, regolare il controllo dell'accesso o modificare le convenzioni di denominazione in base alle preferenze di framework di rete come Alamofire / Moya.
Il sistema di tipi di Swift è rinomato per la sua sicurezza. struct è un tipo valore, adatto a rappresentare dati immutabili; class è un tipo riferimento, adatto a scenari che richiedono stato condiviso o ereditarietà. Le proprietà generate da questo strumento sono mappate il più fedelmente possibile a String, Int, Double, Bool, [T], tipi personalizzati, ecc. di Swift. Dopo la generazione, gli sviluppatori possono modificare alcuni campi in Optional (?) in base alle esigenze di business, aggiungere il protocollo Codable ai tipi, o promuovere un intero struct a class per ottenere la semantica di riferimento.
La gestione degli oggetti annidati è una capacità chiave dello strumento. Quando il JSON contiene oggetti annidati, lo strumento genera ricorsivamente sottotipi indipendenti; ad esempio, quando Root contiene un oggetto address, viene generato un tipo Address, e il tipo principale lo referenzia tramite var address: Address. Questo evita definizioni di tipo duplicate e consente all'autocompletamento e al controllo dei tipi di Xcode di tracciare correttamente le relazioni gerarchiche. La regola di denominazione mette in maiuscolo la prima lettera del nome del campo; ad esempio, gli elementi in un array users sono denominati User.
L'inferenza del tipo di array segue una strategia "deduisci dal primo elemento". Se gli elementi dell'array sono stringhe viene generato [String]; se interi [Int]; se numeri in virgola mobile [Double]; se oggetti [tipo personalizzato]. Gli array vuoti [] mancano di esempi, quindi viene generato [Any] o un tipo di fallback; dopo la generazione si consiglia di cambiarli in tipi concreti in base al business reale. Per array particolarmente grandi o sparsi, si consiglia di inserire elementi di esempio reali nel JSON sorgente per migliorare la precisione dell'inferenza.
L'elaborazione pura nel frontend è il vantaggio architetturale centrale di questo strumento. Tutto il parsing JSON e la generazione del codice Swift vengono eseguiti in JavaScript del browser (incluso quicktype-core in un Web Worker), indipendentemente dai servizi backend, e nessun dato viene inviato a nessun server. Questo design protegge i dati JSON che potrebbero contenere informazioni sensibili e garantisce che la velocità di conversione sia limitata solo dalle prestazioni del dispositivo locale, senza attendere i round-trip di rete. È particolarmente importante durante l'elaborazione di JSON contenente chiavi API o campi di business non pubblicati.
A differenza di alcuni strumenti online che legano forzatamente le strategie di decodifica Codable / CodingKeys / Date, questo strumento aderisce a un principio di output minimo: i membri del team hanno spesso preferenze diverse su protocolli, denominazione e controllo dell'accesso, e questo strumento lascia le scelte di protocolli e strategie agli sviluppatori per affinarle per progetto. Questo flusso di lavoro "genera un semilavorato + rielaborazione secondaria a livello di progetto" è generalmente più popolare tra gli ingegneri nei team di medie e grandi dimensioni rispetto alle soluzioni "tutto in un clic".
L'uso più comune nei progetti iOS/macOS: aggiungi Codable agli struct generati da questo strumento, quindi recupera in modo asincrono con URLSession e decodifica con JSONDecoder.
import Foundation
// 1) Tipo radice generato da questo strumento (con protocollo Codable aggiunto)
struct User: Codable {
let id: Int
let name: String
let email: String
let isActive: Bool
let tags: [String]
}
// 2) Recupero e decodifica asincrona 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) Esempio di utilizzo (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)
}
}Quando usi Alamofire, puoi usare direttamente responseDecodable per decodificare automaticamente gli struct generati da questo strumento in oggetti Swift.
import Foundation
import Alamofire
// Tipo generato da questo strumento, utilizzabile direttamente dopo aver aggiunto 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 stile 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)
}
}
}
}
}
// Esempio di chiamata stile Moya
// provider.request(.product(id: 1)).map(Product.self)
// let product: Product = try await provider.request(.product(id: 1)).map(Product.self)Nei progetti SwiftUI / Combine, puoi utilizzare gli struct generati insieme a dataTaskPublisher / decode per flussi di dati reattivi.
import Foundation
import Combine
// Tipo radice generato da questo strumento
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
}
/// Esponi il flusso di dati con 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()
}
/// Sottoscrivi 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?
}Incolla il contenuto JSON nella casella di input a sinistra. Dopo un debounce di 400ms, lo strumento chiama automaticamente quicktype-core per convertirlo in codice Swift e mostra il risultato nel pannello di destra in tempo reale. Puoi anche cliccare il pulsante di upload per selezionare un file .json / .txt, o cliccare il pulsante di esempio per caricare dati integrati. Dopo il completamento della conversione puoi copiare il risultato o scaricarlo come file .swift in un clic.
Per impostazione predefinita no. Questo strumento utilizza la modalità just-types di quicktype-core, che produce dichiarazioni di proprietà struct/class pure senza annotazioni Codable, Decodable o Encodable, e senza istruzioni import. Se hai bisogno di Codable, aggiungi semplicemente : Codable dopo la generazione (es. struct User: Codable {}), o scrivi la tua logica di parsing con JSONDecoder.
È supportato tutto il JSON valido: tipi base (null, boolean, number, string), array monodimensionali o multidimensionali e oggetti annidati di profondità arbitraria. L'input radice può essere un oggetto JSON o un array JSON; lo strumento dà priorità agli oggetti e deduce gli array dal loro primo elemento. Gli input non supportati includono valori speciali JavaScript (funzioni, Symbol, undefined) e testo non JSON.
Lo strumento genera ricorsivamente tipi Swift indipendenti per ogni oggetto annidato. I nomi si basano su una combinazione del nome del tipo padre e del nome del campo; ad esempio, se Root contiene un campo address, viene generato un sottotipo Address, e il tipo principale lo referenzia tramite var address: Address. Questo evita definizioni di tipo duplicate e consente all'autocompletamento e al controllo dei tipi di Xcode di tracciare correttamente le relazioni gerarchiche.
Sì. Gli array JSON vengono convertiti automaticamente nella forma [T] di Swift. Se gli elementi dell'array sono stringhe viene generato [String]; se interi [Int]; se numeri in virgola mobile [Double]; se oggetti [tipo personalizzato]. Gli array vuoti [] non hanno elementi di esempio, quindi viene generato [Any] per impostazione predefinita; dopo la generazione si consiglia di cambiarlo manualmente in un tipo concreto come [String] o [Int].
I valori null in JSON non possono dedurre il tipo concreto; lo strumento può generare Any o un tipo di fallback. Si consiglia di sostituire i campi con valore null nel JSON sorgente con valori di esempio (es. "field": "" deduce String) o di cambiarli manualmente in Optional in base alla logica di business (es. var phone: String?), il che si allinea meglio alla semantica di sicurezza del sistema di tipi di Swift.
Sì. Clicca il pulsante del nome del tipo (o l'ingresso delle impostazioni) nella barra degli strumenti per modificare il nome del tipo radice (il predefinito è Root o dedotto dai dati di esempio). I nomi dei sottotipi vengono generati automaticamente in base al nome radice e ai nomi dei campi; la regola di denominazione è mettere in maiuscolo la prima lettera del nome del campo, es. users → User, tags → Tag.
Lo strumento rileva automaticamente la validità del JSON; in caso di errore mostra un messaggio di errore specifico a destra e fornisce un pulsante "Ripara JSON". Cliccandolo vengono riparati automaticamente errori comuni: virgole finali, virgolette singole sostituite con virgolette doppie, virgolette mancanti sulle chiavi, rimozione di commenti, ecc. Dopo la riparazione riuscita puoi continuare la conversione senza correggere manualmente il JSON.
Viene eseguito completamente nel tuo browser. Tutto il parsing JSON e la generazione del codice Swift avvengono localmente tramite JavaScript del browser (incluso quicktype-core in un Web Worker); il JSON che inserisci e il codice Swift generato non vengono mai caricati su alcun server, né vengono registrati o salvati nella cache nel cloud. Il JSON sensibile contenente chiavi API, token, campi di privacy utente o strutture di business non pubblicate può essere utilizzato in sicurezza — chiudendo la pagina tutto viene cancellato.
Sì. Il codice generato è sintassi Swift standard e può essere copiato direttamente in un file .swift di Xcode, o salvato come file .swift tramite il pulsante "Download" e trascinato nel tuo progetto. Poiché l'output sono dichiarazioni di tipo pure, si consiglia di aggiungere manualmente protocolli come Codable, Equatable, Identifiable secondo necessità, o di regolare i modificatori di controllo dell'accesso (public / internal / private).
Sì. Quando l'input radice è un array JSON, lo strumento utilizza il primo elemento dell'array come modello per generare un tipo di elemento e restituisce la definizione di quel tipo di elemento. Ad esempio, [{"id":1,"name":"A"}] genera uno struct chiamato Item (o un nome dedotto dai campi) i cui campi sono quelli del primo elemento; il tipo principale lo referenzia tramite una proprietà items: [Item], evitando di trattare l'array direttamente come tipo radice.
Non c'è un limite di dimensione esplicito, ma il browser rallenterà durante il parsing e il rendering di JSON molto grandi. Consigli: ① Converti JSON di un solo modulo di business alla volta; ② Dividi livelli di annidamento profondi ed elaborali separatamente; ③ Per JSON di oltre pochi MB puoi usare la versione da riga di comando di quicktype; ④ Dividere lo stesso JSON in più sottomoduli e convertirli separatamente può ridurre significativamente l'utilizzo della memoria.
Entrambi convertono JSON in definizioni di tipo per i rispettivi linguaggi, ma il loro focus differisce: JSON in Swift genera dichiarazioni di proprietà struct/class per app native iOS/macOS; JSON in TypeScript genera dichiarazioni interface/type per il controllo dei tipi frontend. Se il tuo progetto ha sia un client iOS che un frontend Web, si consiglia di generare entrambe le versioni Swift e TS dallo stesso JSON per garantire la coerenza dei tipi su entrambi i lati.
Questo strumento genera tipi puri per impostazione predefinita senza protocolli. Dopo la generazione devi solo aggiungere : Codable dopo la dichiarazione struct/class, es. struct User: Codable {}, e JSONDecoder può usarlo. Se vuoi Codable per impostazione predefinita puoi fare fork di quicktype-core e modificare il suo renderer Swift, o usare la sostituzione in batch di Xcode per aggiungere il protocollo a tutti i tipi dopo la generazione.
La prima visita richiede Internet per caricare gli script dello strumento e le risorse quicktype-core; successivamente può funzionare offline dalla cache del browser (in un browser già visitato). Anche i browser mobile (iOS Safari, Android Chrome) funzionano normalmente; l'interfaccia utilizza un design a schermo diviso responsive che passa automaticamente all'impilamento verticale in orientamento verticale.
Sì. Dopo la generazione ogni tipo Swift è uno struct/class indipendente; l'output dello strumento è testo semplice. Puoi copiare individualmente un singolo tipo e incollarlo in Xcode, o usare il refactoring Rename di Xcode per modificare in batch tipi e campi senza influenzare altri tipi. Se hai bisogno di rigenerare l'intero gruppo di tipi, aggiorna semplicemente la pagina e incolla nuovamente il JSON.
Il supporto di quicktype per union/enum richiede suggerimenti di tipo aggiuntivi o input GraphQL/JSON Schema. Dedurre enum da soli campioni JSON è difficile, quindi questo strumento non genera enum per impostazione predefinita. Se hai bisogno di enum puoi modificare manualmente lo struct corrispondente in un enum + Codable, o usare prima uno strumento JSON in Kotlin/TypeScript per ottenere tipi enum e poi migrarli manualmente in Swift.
La casella di input a sinistra è vuota o contiene solo spazi bianchi. Incolla contenuto JSON valido, o clicca "Esempio" per caricare un esempio, o "Carica" per selezionare un file .json / .txt.
Il JSON è malformato. Cause comuni: ① virgola finale (es. {"a":1,}); ② virgolette singole usate al posto di virgolette doppie; ③ sintassi oggetto JS (es. {key: value}) invece di JSON (es. {"key": "value"}); ④ contiene commenti JavaScript. Cliccando il pulsante "Ripara JSON" è possibile riparare automaticamente alcuni errori comuni.
Questo è il comportamento atteso. Questo strumento utilizza la modalità just-types e genera dichiarazioni di proprietà struct/class pure. Se hai bisogno di Codable, aggiungi : Codable ai tipi dopo la generazione (es. struct User: Codable {}), o scrivi extension User: Codable {} prima di chiamare JSONDecoder.
Gli array vuoti non hanno elementi di esempio, quindi lo strumento genera il tipo di fallback [Any]. Si consiglia di inserire almeno un elemento di esempio nel JSON sorgente (es. [1, 2]), eliminare il valore di esempio dopo la generazione e specificare manualmente un tipo concreto; o passare direttamente a un tipo più preciso come [String] / [User] dopo la generazione.
JSON null non può dedurre il tipo concreto; lo strumento può generare Any o un tipo di fallback. Si consiglia di sostituire null nel JSON sorgente con un valore di esempio rappresentativo (es. "" o 0), quindi cambiare quel campo in Optional (?) o in un tipo concreto dopo la generazione, es. var phone: String?.
Puoi modificare il nome del tipo radice nella barra degli strumenti; i nomi dei sottotipi vengono generati automaticamente in base al nome radice + ai nomi dei campi. Se ancora insoddisfatto, usa il refactoring Rename di Xcode per la modifica in batch dopo la generazione (clic destro → Refactor → Rename); Xcode aggiornerà sincronamente tutte le riferimenti.
Il browser rallenta durante il rendering di JSON molto grandi e la generazione di molti tipi. Si consiglia di dividere il JSON in più moduli di business indipendenti e convertirli separatamente, o estrarre solo gli oggetti chiave che necessitano di modellazione; per JSON oltre i 10 MB consigliamo la versione da riga di comando di quicktype.
Significa che hai aggiunto Codable ad alcuni campi ma non hai gestito correttamente i tipi Optional / Date / Enum. Correzioni comuni: ① Passa tutti i campi che possono essere null a Optional<T>; ② Personalizza la strategia delle date con JSONDecoder().dateDecodingStrategy = .iso8601; ③ Personalizza CodingKeys per allineare le chiavi JSON ai nomi delle proprietà Swift.
Questo strumento conserva i nomi originali dei campi JSON per impostazione predefinita, quindi i campi snake_case vengono generati così come sono. Se vuoi unificare a camelCase puoi rinominare in batch usando Rename di Xcode dopo la generazione, o convertire i nomi dei campi in camelCase in un renderer quicktype personalizzato, quindi aggiungere mappature CodingKeys per garantire una decodifica JSON corretta.
Swift raccomanda nomi di campo come identificatori ASCII inglesi. Se il JSON sorgente contiene chiavi cinesi (es. {"姓名": "Alice"}), il var 姓名: String generato causerà errori del compilatore Swift in alcune versioni precedenti. Si consiglia di cambiare le chiavi in inglese (es. name) nel JSON sorgente, il che è più conforme alle norme di codifica Swift.
Questo strumento genera proprietà var public per impostazione predefinita per facilitare la post-elaborazione. Se vuoi let o il controllo dell'accesso (es. private(set)), puoi modificare in batch usando Refactor di Xcode → Add Access Control, o sostituire var con let usando sed / uno strumento di editing del testo dopo la generazione.
Questo strumento mappa le stringhe ISO 8601 a String per impostazione predefinita; Swift non le converte automaticamente in Date. Devi impostare dateDecodingStrategy in JSONDecoder, es. JSONDecoder().dateDecodingStrategy = .iso8601. Se il formato della data non è standard dovrai anche implementare manualmente un DateFormatter o una logica di parsing personalizzata.
Lo strumento nomina i sottotipi "mettendo in maiuscolo la prima lettera del nome del campo". Il JSON profondamente annidato può avere oggetti annidati con lo stesso nome che causano conflitti di tipo. Soluzioni: ① Aggiungi prefissi di business ai campi nel JSON sorgente; ② Dividi il JSON radice in più moduli indipendenti e genera separatamente; ③ Usa Rename di Xcode per modificare in batch i nomi dei tipi in conflitto dopo la generazione.
Questo strumento genera internal struct per impostazione predefinita senza un modificatore public esplicito. Se il tuo progetto è diviso per moduli e richiede l'accesso tra moduli, devi sostituire in batch struct con public struct in Xcode, o aggiungere uniformemente la parola chiave public usando script sed/awk dopo la generazione.
Lo strumento deduce automaticamente i tipi Swift corrispondenti in base alla forma dei valori JSON:
| Esempio di valore JSON | Metodo di rilevamento | Tipo Swift generato | Note |
|---|---|---|---|
null | value === null | Any? o Optional concreto | Impossibile dedurre il tipo concreto; consiglia di passare manualmente a Optional<T> dopo la generazione |
true / false | typeof value === 'boolean' | Bool | Mappato direttamente al tipo Bool di Swift |
42 | typeof value === 'number' && Number.isInteger(value) | Int | Gli interi sono mappati a Int (32/64 bit determinato dalla piattaforma) |
3.14 | typeof value === 'number' && !Number.isInteger(value) | Double | I numeri in virgola mobile sono mappati a Double |
"hello" | typeof value === 'string' | String | Le stringhe sono mappate a String |
[] (array vuoto) | Array.isArray(value) && value.length === 0 | [Any] | Impossibile dedurre il tipo di elemento; consiglia di aggiungere un esempio o passare manualmente a un tipo concreto |
["a", "b"] | Array.isArray(value) && typeof value[0] === 'string' | [String] | Array di stringhe |
[1, 2, 3] | Array.isArray(value) && typeof value[0] === 'number' | [Int] | Array di interi |
[1.5, 2.5] | Array.isArray(value) && typeof value[0] === 'number' && !Number.isInteger(value[0]) | [Double] | Array di float |
[{...}, {...}] | Array.isArray(value) && typeof value[0] === 'object' | [Item] | Array di oggetti, gli elementi sono tipi personalizzati, nomi dedotti dai nomi dei campi |
{...} (oggetto annidato) | typeof value === 'object' && !Array.isArray(value) | struct / class indipendente | Genera ricorsivamente tipi indipendenti, denominati mettendo in maiuscolo i nomi dei campi |
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 |
Questo strumento JSON in Swift esegue tutte le operazioni di parsing JSON e generazione di tipi Swift completamente nel tuo browser tramite JavaScript (quicktype-core / Web Worker). I dati JSON che inserisci e il codice Swift generato non vengono mai caricati su alcun server, né registrati, salvati nella cache o archiviati nel cloud. Il JSON sensibile contenente campi API interni, chiavi API, token, dati di privacy utente o strutture di business non pubblicate può essere utilizzato in sicurezza; tutto il contenuto di input e output viene automaticamente cancellato dalla memoria quando chiudi o aggiorni la pagina, senza dipendere da servizi di rete di terze parti.