Kein Inhalt
Kostenloser Online-JSON-zu-Swift-Konverter. Wandeln Sie API-Antworten, Konfigurationsdateien oder Log-JSON mit einem Klick in reine Swift struct/class-Typdeklarationen um. Keine Registrierung, kein Upload — Echtzeit-Generierung in Ihrem Browser. Perfekt für die schnelle Modellierung in iOS-, macOS-, watchOS- und tvOS-Projekten.
JSON zu Swift ist der Prozess der automatischen Konvertierung von JSON-formatierten Daten (Objekten oder Arrays) in Swift struct/class-Typdeklarationen. JSON ist der De-facto-Standard für REST-APIs, Konfigurationsdateien und Analyse-Logs, während Swift die primäre Entwicklungssprache für iOS-, macOS-, watchOS- und tvOS-Anwendungen sowie eine Kernsprache für serverseitige Frameworks wie Vapor ist. In der Entwicklung ist es häufig notwendig, entsprechende Swift-Typen für von APIs zurückgegebenes JSON zu schreiben; das manuelle Schreiben ist zeitaufwändig und anfällig für das Übersehen optionaler Felder. Der Zweck dieses Tools besteht darin, diesen Prozess zu automatisieren.
Dieses Tool verwendet quicktype-core, um die Konvertierung lokal im Browser durchzuführen. quicktype ist ein mehrsprachiger Strukturgenerator; dieses Tool aktiviert die just-types- und no-comments-Optionen für Swift, sodass die Ausgabe saubere struct/class-Eigenschaftsdeklarationen ohne Serialisierungsannotation wie Codable, Decodable oder Encodable und ohne Import-Anweisungen oder Dateikopfkommentare ist. Diese „nackten Typen“ ermöglichen es Entwicklern, frei Protokolle hinzuzufügen, die Zugriffssteuerung anzupassen oder Namenskonventionen an die Präferenzen von Netzwerk-Frameworks wie Alamofire / Moya zu ändern.
Swifts Typsystem ist für seine Sicherheit bekannt. struct ist ein Werttyp, geeignet zur Darstellung unveränderlicher Daten; class ist ein Referenztyp, geeignet für Szenarien, die gemeinsamen Zustand oder Vererbung erfordern. Von diesem Tool generierte Eigenschaften werden so genau wie möglich auf Swifts String, Int, Double, Bool, [T], benutzerdefinierte Typen usw. abgebildet. Nach der Generierung können Entwickler bestimmte Felder je nach Geschäftsanforderungen in Optional (?) ändern, Typen das Codable-Protokoll hinzufügen oder ein gesamtes struct zu einer class hochstufen, um Referenzsemantik zu erhalten.
Die Handhabung verschachtelter Objekte ist eine Schlüsselfähigkeit des Tools. Wenn JSON verschachtelte Objekte enthält, generiert das Tool rekursiv unabhängige Untertypen; wenn Root beispielsweise ein address-Objekt enthält, wird ein Address-Typ generiert, und der Haupttyp referenziert ihn über var address: Address. Dies vermeidet doppelte Typdefinitionen und ermöglicht es der Autovervollständigung und Typprüfung von Xcode, Hierarchiebeziehungen korrekt zu verfolgen. Die Benennungsregel schreibt den ersten Buchstaben des Feldnamens groß; beispielsweise werden Elemente in einem users-Array als User benannt.
Die Array-Typinferenz folgt einer Strategie „Inferenz nach erstem Element“. Wenn Array-Elemente Strings sind, wird [String] generiert; bei Ganzzahlen [Int]; bei Gleitkommazahlen [Double]; bei Objekten [benutzerdefinierter Typ]. Leere Arrays [] fehlen Beispiele, daher wird [Any] oder ein Fallback-Typ generiert; nach der Generierung wird empfohlen, sie je nach tatsächlichem Geschäft auf konkrete Typen zu ändern. Für besonders große oder lückenhafte Arrays wird empfohlen, echte Beispielelemente in das Quell-JSON einzufügen, um die Inferenzgenauigkeit zu verbessern.
Die reine Frontend-Verarbeitung ist der zentrale Architekturvorteil dieses Tools. Das gesamte JSON-Parsing und die Swift-Code-Generierung werden in Browser-JavaScript ausgeführt (einschließlich quicktype-core in einem Web Worker), unabhängig von Backend-Diensten, und es werden keine Daten an einen Server gesendet. Dieses Design schützt JSON-Daten, die vertrauliche Informationen enthalten können, und stellt sicher, dass die Konvertierungsgeschwindigkeit nur durch die Leistung des lokalen Geräts begrenzt ist, ohne auf Netzwerkumlauzeiten warten zu müssen. Es ist besonders wichtig bei der Verarbeitung von JSON, das API-Schlüssel oder unveröffentlichte Geschäftsfelder enthält.
Im Gegensatz zu einigen Online-Tools, die Codable / CodingKeys / Date-Decodierungsstrategien zwangsweise binden, hält sich dieses Tool an ein Minimalausgabeprinzip: Teammitglieder haben oft unterschiedliche Präferenzen bezüglich Protokollen, Namensgebung und Zugriffssteuerung, und dieses Tool überlässt die Protokoll- und Strategiewahl den Entwicklern zur projektbezogenen Verfeinerung. Dieser Arbeitsablauf „Halbzeug generieren + projektbezogene Nachbearbeitung“ ist bei Ingenieuren in mittleren und großen Teams im Allgemeinen beliebter als Lösungen „mit einem Klick alles erledigen“.
Die häufigste Verwendung in iOS/macOS-Projekten: Fügen Sie den von diesem Tool generierten Structs Codable hinzu, rufen Sie sie dann asynchron mit URLSession ab und dekodieren Sie sie mit JSONDecoder.
import Foundation
// 1) Von diesem Tool generierter Root-Typ (mit hinzugefügtem Codable-Protokoll)
struct User: Codable {
let id: Int
let name: String
let email: String
let isActive: Bool
let tags: [String]
}
// 2) Asynchrones Abrufen und Dekodieren mit 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) Nutzungsbeispiel (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)
}
}Bei Verwendung von Alamofire können Sie responseDecodable direkt verwenden, um von diesem Tool generierte Structs automatisch in Swift-Objekte zu deserialisieren.
import Foundation
import Alamofire
// Von diesem Tool generierter Typ, nach Hinzufügen von Codable direkt verwendbar
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-Stil 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-Stil-Aufrufbeispiel
// provider.request(.product(id: 1)).map(Product.self)
// let product: Product = try await provider.request(.product(id: 1)).map(Product.self)In SwiftUI / Combine-Projekten können Sie generierte Structs zusammen mit dataTaskPublisher / decode für reaktive Datenströme verwenden.
import Foundation
import Combine
// Von diesem Tool generierter Root-Typ
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
}
/// Datenstrom mit Combine bereitstellen
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()
}
/// In SwiftUI ViewModel abonnieren
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?
}Fügen Sie Ihren JSON-Inhalt in die linke Eingabebox ein. Nach einem 400ms-Debounce ruft das Tool automatisch quicktype-core auf, um es in Swift-Code zu konvertieren, und zeigt das Ergebnis in Echtzeit im rechten Panel an. Sie können auch auf die Upload-Schaltfläche klicken, um eine .json / .txt-Datei auszuwählen, oder auf die Beispiel-Schaltfläche klicken, um integrierte Daten zu laden. Nach Abschluss der Konvertierung können Sie das Ergebnis kopieren oder als .swift-Datei herunterladen.
Standardmäßig nicht. Dieses Tool verwendet den just-types-Modus von quicktype-core, der reine struct/class-Eigenschaftsdeklarationen ohne Codable-, Decodable- oder Encodable-Annotationen und ohne Import-Anweisungen ausgibt. Wenn Sie Codable benötigen, fügen Sie nach der Generierung einfach : Codable hinzu (z. B. struct User: Codable {}), oder schreiben Sie Ihre eigene JSONDecoder-Parsing-Logik.
Alle gültigen JSON werden unterstützt: Basistypen (null, boolean, number, string), ein- oder mehrdimensionale Arrays und verschachtelte Objekte beliebiger Tiefe. Die Root-Eingabe kann ein JSON-Objekt oder ein JSON-Array sein; das Tool priorisiert Objekte und inferiert Arrays anhand ihres ersten Elements. Nicht unterstützte Eingaben umfassen JavaScript-Spezialwerte (Funktionen, Symbol, undefined) und Nicht-JSON-Text.
Das Tool generiert rekursiv unabhängige Swift-Typen für jedes verschachtelte Objekt. Die Benennung basiert auf einer Kombination aus übergeordnetem Typnamen und Feldnamen; wenn Root beispielsweise ein address-Feld enthält, wird ein Untertyp Address generiert, und der Haupttyp referenziert ihn über var address: Address. Dies vermeidet doppelte Typdefinitionen und ermöglicht es der Autovervollständigung und Typprüfung von Xcode, Hierarchiebeziehungen korrekt zu verfolgen.
Ja. JSON-Arrays werden automatisch in die Swift-Form [T] konvertiert. Wenn Array-Elemente Strings sind, wird [String] generiert; bei Ganzzahlen [Int]; bei Gleitkommazahlen [Double]; bei Objekten [benutzerdefinierter Typ]. Leere Arrays [] haben keine Beispielelemente, daher wird standardmäßig [Any] generiert; nach der Generierung wird empfohlen, ihn manuell in einen konkreten Typ wie [String] oder [Int] zu ändern.
null-Werte in JSON können ihren konkreten Typ nicht inferieren; das Tool kann Any oder einen Fallback-Typ generieren. Es wird empfohlen, null-wertige Felder im Quell-JSON durch Beispielwerte zu ersetzen (z. B. "field": "" inferiert String) oder sie manuell in Optional zu ändern (z. B. var phone: String?), was besser zur Sicherheitssemantik von Swifts Typsystem passt.
Ja. Klicken Sie auf die Typnamen-Schaltfläche (oder den Einstellungseintrag) in der Symbolleiste, um den Root-Typnamen zu ändern (Standard ist Root oder wird aus Beispieldaten inferiert). Untertypnamen werden automatisch basierend auf dem Root-Namen und den Feldnamen generiert; die Benennungsregel besteht darin, den ersten Buchstaben des Feldnamens großzuschreiben, z. B. users → User, tags → Tag.
Das Tool erkennt automatisch die Gültigkeit des JSON; bei einem Fehler wird eine spezifische Fehlermeldung rechts angezeigt und eine Schaltfläche „JSON reparieren“ bereitgestellt. Durch Klicken werden häufige Fehler automatisch repariert: abschließende Kommas, einfache durch doppelte Anführungszeichen ersetzt, fehlende Anführungszeichen bei Schlüsseln ergänzt, Kommentare entfernt usw. Nach erfolgreicher Reparatur können Sie mit der Konvertierung fortfahren, ohne das JSON manuell korrigieren zu müssen.
Es läuft vollständig in Ihrem Browser. Das gesamte JSON-Parsing und die Swift-Code-Generierung erfolgen lokal über Browser-JavaScript (einschließlich quicktype-core in einem Web Worker); das von Ihnen eingegebene JSON und der generierte Swift-Code werden niemals an einen Server hochgeladen, noch in der Cloud aufgezeichnet oder zwischengespeichert. Sensibles JSON mit API-Schlüsseln, Tokens, Benutzerdatenschutzfeldern oder unveröffentlichten Geschäftsstrukturen kann sicher verwendet werden — beim Schließen der Seite wird alles gelöscht.
Ja. Der generierte Code ist Standard-Swift-Syntax und kann direkt in eine .swift-Datei von Xcode kopiert oder über die Schaltfläche „Herunterladen“ als .swift-Datei gespeichert und in Ihr Projekt gezogen werden. Da die Ausgabe reine Typdeklarationen sind, wird empfohlen, manuell Protokolle wie Codable, Equatable, Identifiable nach Bedarf hinzuzufügen oder Zugriffssteuermodifikatoren (public / internal / private) anzupassen.
Ja. Wenn die Root-Eingabe ein JSON-Array ist, verwendet das Tool das erste Element des Arrays als Vorlage, um einen Elementtyp zu generieren, und gibt diese Elementtypdefinition aus. Zum Beispiel generiert [{"id":1,"name":"A"}] ein Struct namens Item (oder einen aus den Feldern abgeleiteten Namen), dessen Felder die des ersten Elements sind; der Haupttyp referenziert es über eine Eigenschaft items: [Item], wodurch vermieden wird, das Array direkt als Root-Typ zu behandeln.
Es gibt keine explizite Größenbeschränkung, aber der Browser wird beim Parsen und Rendern sehr großer JSON langsamer. Empfehlungen: ① Konvertieren Sie JSON nur eines Geschäftsmoduls gleichzeitig; ② Teilen Sie tiefe Verschachtelungsebenen und verarbeiten Sie diese getrennt; ③ Für JSON über mehrere MB können Sie die Kommandozeilenversion von quicktype verwenden; ④ Das Aufteilen desselben JSON in mehrere Submodule und deren separate Konvertierung kann die Speichernutzung erheblich reduzieren.
Beide konvertieren JSON in Typdefinitionen für ihre jeweiligen Sprachen, aber ihr Fokus unterscheidet sich: JSON zu Swift generiert struct/class-Eigenschaftsdeklarationen für native iOS/macOS-Apps; JSON zu TypeScript generiert interface/type-Deklarationen für die Frontend-Typprüfung. Wenn Ihr Projekt sowohl einen iOS-Client als auch ein Web-Frontend hat, wird empfohlen, sowohl Swift- als auch TS-Versionen aus demselben JSON zu generieren, um die Typkonsistenz auf beiden Seiten sicherzustellen.
Dieses Tool generiert standardmäßig reine Typen ohne Protokolle. Nach der Generierung müssen Sie nur : Codable nach der struct/class-Deklaration hinzufügen, z. B. struct User: Codable {}, und JSONDecoder kann es verwenden. Wenn Sie Codable standardmäßig wünschen, können Sie quicktype-core forken und seinen Swift-Renderer anpassen oder die Stapelersetzung von Xcode verwenden, um das Protokoll nach der Generierung allen Typen hinzuzufügen.
Der erste Besuch erfordert Internet, um Tool-Skripte und quicktype-core-Ressourcen zu laden; danach kann es offline aus dem Browser-Cache laufen (in einem bereits besuchten Browser). Mobile Browser (iOS Safari, Android Chrome) funktionieren ebenfalls normal; die Benutzeroberfläche verwendet ein responsives Split-Screen-Design, das im Hochformat automatisch zur vertikalen Stapelung wechselt.
Ja. Nach der Generierung ist jeder Swift-Typ ein unabhängiges struct/class; die Ausgabe des Tools ist reiner Text. Sie können einen einzelnen Typ einzeln kopieren und in Xcode einfügen oder die Refaktorisierung „Rename“ von Xcode verwenden, um Typen und Felder stapelweise zu ändern, ohne andere Typen zu beeinflussen. Wenn Sie die gesamte Typgruppe neu generieren müssen, aktualisieren Sie einfach die Seite und fügen Sie das JSON erneut ein.
Die Unterstützung von quicktype für Unions/Enums erfordert zusätzliche Typhinweise oder GraphQL/JSON Schema-Eingaben. Das Inferieren von Enums allein aus JSON-Beispielen ist schwierig, daher generiert dieses Tool standardmäßig keine Enums. Wenn Sie Enums benötigen, können Sie das entsprechende struct manuell in ein enum + Codable ändern oder zuerst ein JSON-zu-Kotlin/TypeScript-Tool verwenden, um Enum-Typen zu erhalten, und diese dann manuell zu Swift migrieren.
Die linke Eingabebox ist leer oder enthält nur Leerzeichen. Bitte fügen Sie gültigen JSON-Inhalt ein oder klicken Sie auf „Beispiel“, um ein Beispiel zu laden, oder auf „Hochladen“, um eine .json / .txt-Datei auszuwählen.
Das JSON ist fehlerhaft. Häufige Ursachen: ① abschließendes Komma (z. B. {"a":1,}); ② einfache statt doppelter Anführungszeichen; ③ JS-Objektsyntax (z. B. {key: value}) statt JSON (z. B. {"key": "value"}); ④ enthält JavaScript-Kommentare. Durch Klicken auf die Schaltfläche „JSON reparieren“ können einige häufige Fehler automatisch repariert werden.
Dies ist erwartetes Verhalten. Dieses Tool verwendet den just-types-Modus und gibt reine struct/class-Eigenschaftsdeklarationen aus. Wenn Sie Codable benötigen, fügen Sie den Typen nach der Generierung : Codable hinzu (z. B. struct User: Codable {}), oder schreiben Sie extension User: Codable {}, bevor Sie JSONDecoder aufrufen.
Leere Arrays haben keine Beispielelemente, daher generiert das Tool den Fallback-Typ [Any]. Es wird empfohlen, mindestens ein Beispielelement in das Quell-JSON einzufügen (z. B. [1, 2]), den Beispielwert nach der Generierung zu löschen und manuell einen konkreten Typ anzugeben; oder direkt nach der Generierung zu einem präziseren Typ wie [String] / [User] zu wechseln.
JSON null kann seinen konkreten Typ nicht inferieren; das Tool kann Any oder einen Fallback-Typ generieren. Es wird empfohlen, null im Quell-JSON durch einen repräsentativen Beispielwert zu ersetzen (z. B. "" oder 0) und dann dieses Feld nach der Generierung in Optional (?) oder einen konkreten Typ zu ändern, z. B. var phone: String?.
Sie können den Root-Typnamen in der Symbolleiste ändern; Untertypnamen werden automatisch basierend auf Root-Name + Feldnamen generiert. Wenn Sie immer noch unzufrieden sind, verwenden Sie die Rename-Refaktorisierung von Xcode zur Stapeländerung nach der Generierung (Rechtsklick → Refactor → Rename); Xcode aktualisiert alle Referenzen synchron.
Der Browser wird beim Rendern sehr großer JSON und der Generierung vieler Typen langsamer. Es wird empfohlen, das JSON in mehrere unabhängige Geschäftsmodule aufzuteilen und separat zu konvertieren oder nur Schlüsselobjekte zu extrahieren, die modelliert werden müssen; für JSON über 10 MB empfehlen wir die Kommandozeilenversion von quicktype.
Dies bedeutet, dass Sie einigen Feldern Codable hinzugefügt haben, aber Optional / Date / Enum-Typen nicht korrekt behandelt haben. Häufige Korrekturen: ① Ändern Sie alle Felder, die null sein können, in Optional<T>; ② Passen Sie die Datumsstrategie mit JSONDecoder().dateDecodingStrategy = .iso8601 an; ③ Passen Sie CodingKeys an, um JSON-Schlüssel mit Swift-Eigenschaftsnamen auszurichten.
Dieses Tool behält ursprüngliche JSON-Feldnamen standardmäßig bei, daher werden snake_case-Felder so wie sie sind generiert. Wenn Sie zu camelCase vereinheitlichen möchten, können Sie nach der Generierung mit Xcode Rename stapelweise umbenennen oder Feldnamen in einem benutzerdefinierten quicktype-Renderer in camelCase umwandeln und dann CodingKeys-Mappings hinzufügen, um korrektes JSON-Decodieren sicherzustellen.
Swift empfiehlt Feldnamen als englische ASCII-Identifikatoren. Wenn das Quell-JSON chinesische Schlüssel enthält (z. B. {"姓名": "Alice"}), wird das generierte var 姓名: String in einigen älteren Versionen Swift-Compiler-Fehler verursachen. Es wird empfohlen, die Schlüssel im Quell-JSON in Englisch zu ändern (z. B. name), was besser den Swift-Codierstandards entspricht.
Dieses Tool generiert standardmäßig var public-Eigenschaften zur einfachen Nachbearbeitung. Wenn Sie let oder Zugriffssteuerung wünschen (z. B. private(set)), können Sie mit Xcode Refactor → Add Access Control stapelweise ändern oder var nach der Generierung mit sed / einem Textbearbeitungstool durch let ersetzen.
Dieses Tool bildet ISO 8601-Strings standardmäßig auf String ab; Swift konvertiert sie nicht automatisch in Date. Sie müssen dateDecodingStrategy in JSONDecoder festlegen, z. B. JSONDecoder().dateDecodingStrategy = .iso8601. Wenn das Datumsformat nicht standardmäßig ist, müssen Sie auch manuell einen DateFormatter oder eine benutzerdefinierte Parsing-Logik implementieren.
Das Tool benennt Untertypen nach „ersten Buchstaben des Feldnamens großschreiben“. Tief verschachteltes JSON kann verschachtelte Objekte mit demselben Namen haben, die Typkonflikte verursachen. Lösungen: ① Fügen Sie Geschäftspräfixe zu Feldern im Quell-JSON hinzu; ② Teilen Sie das Root-JSON in mehrere unabhängige Module auf und generieren Sie separat; ③ Verwenden Sie Xcode Rename, um konfliktbehaftete Typnamen nach der Generierung stapelweise zu ändern.
Dieses Tool generiert standardmäßig internal struct ohne expliziten public-Modifikator. Wenn Ihr Projekt nach Modulen aufgeteilt ist und modulübergreifenden Zugriff erfordert, müssen Sie struct in Xcode stapelweise durch public struct ersetzen oder das public-Schlüsselwort nach der Generierung mit sed/awk-Skripten einheitlich hinzufügen.
Das Tool inferiert automatisch entsprechende Swift-Typen basierend auf der Form von JSON-Werten:
| JSON-Wert-Beispiel | Erkennungsmethode | Generierter Swift-Typ | Hinweise |
|---|---|---|---|
null | value === null | Any? oder konkretes Optional | Kann keinen konkreten Typ inferieren; empfehle manuelle Änderung zu Optional<T> nach Generierung |
true / false | typeof value === 'boolean' | Bool | Direkte Abbildung auf Swift-Bool-Typ |
42 | typeof value === 'number' && Number.isInteger(value) | Int | Ganzzahlen werden auf Int abgebildet (32/64 Bit plattformabhängig) |
3.14 | typeof value === 'number' && !Number.isInteger(value) | Double | Gleitkommazahlen werden auf Double abgebildet |
"hello" | typeof value === 'string' | String | Strings werden auf String abgebildet |
[] (leeres Array) | Array.isArray(value) && value.length === 0 | [Any] | Kann Elementtyp nicht inferieren; empfehle Beispiel hinzufügen oder manuell zu konkretem Typ ändern |
["a", "b"] | Array.isArray(value) && typeof value[0] === 'string' | [String] | String-Array |
[1, 2, 3] | Array.isArray(value) && typeof value[0] === 'number' | [Int] | Ganzzahl-Array |
[1.5, 2.5] | Array.isArray(value) && typeof value[0] === 'number' && !Number.isInteger(value[0]) | [Double] | Gleitkomma-Array |
[{...}, {...}] | Array.isArray(value) && typeof value[0] === 'object' | [Item] | Objekt-Array, Elemente sind benutzerdefinierte Typen, Namen aus Feldnamen inferiert |
{...} (verschachteltes Objekt) | typeof value === 'object' && !Array.isArray(value) | Unabhängiges struct / class | Generiert rekursiv unabhängige Typen, benannt durch Großschreibung von Feldnamen |
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 |
Dieses JSON-zu-Swift-Tool führt alle JSON-Parsing- und Swift-Typgenerierungsvorgänge vollständig in Ihrem Browser über JavaScript (quicktype-core / Web Worker) durch. Die von Ihnen eingegebenen JSON-Daten und der generierte Swift-Code werden niemals an einen Server hochgeladen, noch in der Cloud aufgezeichnet, zwischengespeichert oder gespeichert. Sensibles JSON mit internen API-Feldern, API-Schlüsseln, Tokens, Benutzerdatenschutzdaten oder unveröffentlichten Geschäftsstrukturen kann sicher verwendet werden; alle Eingabe- und Ausgab einhalte werden automatisch aus dem Arbeitsspeicher gelöscht, wenn Sie die Seite schließen oder aktualisieren, ohne auf Netzwerkdienste Dritter angewiesen zu sein.