Aucun contenu
Convertisseur JSON vers Swift gratuit en ligne. Convertissez en un clic des réponses API, des fichiers de configuration ou du JSON de logs en déclarations de types struct/class Swift pures. Sans inscription, sans téléchargement : génération en temps réel dans votre navigateur. Parfait pour la modélisation rapide dans les projets iOS, macOS, watchOS et tvOS.
JSON vers Swift est le processus de conversion automatique de données au format JSON (objets ou tableaux) en déclarations de types struct/class Swift. JSON est le standard de facto pour les API REST, les fichiers de configuration et les journaux d'analyse, tandis que Swift est le langage de développement principal pour les applications iOS, macOS, watchOS et tvOS, ainsi qu'un langage central pour les frameworks côté serveur comme Vapor. Dans le développement, il est fréquemment nécessaire d'écrire les types Swift correspondants pour le JSON renvoyé par les API ; les écrire à la main prend du temps et est sujet à omettre des champs optionnels. Le but de cet outil est d'automatiser ce processus.
Cet outil utilise quicktype-core pour effectuer la conversion localement dans le navigateur. quicktype est un générateur de structures multilingue ; cet outil active les options just-types et no-comments pour Swift, donc la sortie est des déclarations de propriétés struct/class propres sans annotations de sérialisation telles que Codable, Decodable ou Encodable, et sans instructions import ni commentaires d'en-tête. Ces « types nus » permettent aux développeurs d'ajouter librement des protocoles, d'ajuster le contrôle d'accès ou de modifier les conventions de nommage selon les préférences des frameworks réseau comme Alamofire / Moya.
Le système de types de Swift est réputé pour sa sécurité. struct est un type valeur, adapté pour représenter des données immuables ; class est un type référence, adapté aux scénarios nécessitant un état partagé ou de l'héritage. Les propriétés générées par cet outil sont mappées aussi fidèlement que possible vers String, Int, Double, Bool, [T], types personnalisés, etc., de Swift. Après génération, les développeurs peuvent modifier certains champs en Optional (?) selon les besoins métier, ajouter le protocole Codable aux types, ou promouvoir un struct entier en class pour obtenir une sémantique de référence.
La gestion des objets imbriqués est une capacité clé de l'outil. Lorsque le JSON contient des objets imbriqués, l'outil génère récursivement des sous-types indépendants ; par exemple, lorsque Root contient un objet address, un type Address est généré, et le type principal le référence via var address: Address. Cela évite les définitions de types dupliquées et permet à l'autocomplétion et à la vérification de types de Xcode de suivre correctement les relations hiérarchiques. La règle de nommage capitalise la première lettre du nom du champ ; par exemple, les éléments d'un tableau users sont nommés User.
L'inférence de types de tableau suit une stratégie « inférer par le premier élément ». Si les éléments du tableau sont des chaînes, [String] est généré ; si des entiers, [Int] ; si des nombres à virgule flottante, [Double] ; si des objets, [type personnalisé]. Les tableaux vides [] manquent d'échantillons, donc [Any] ou un type de secours est généré ; après génération, il est recommandé de les remplacer par des types concrets selon le métier réel. Pour les tableaux particulièrement volumineux ou creux, il est recommandé de placer des éléments d'exemple réels dans le JSON source pour améliorer la précision de l'inférence.
Le traitement pur en frontend est l'avantage architectural central de cet outil. Toute l'analyse JSON et la génération de code Swift s'exécutent en JavaScript du navigateur (y compris quicktype-core dans un Web Worker), indépendamment des services backend, et aucune donnée n'est envoyée à un serveur. Cette conception protège les données JSON pouvant contenir des informations sensibles et garantit que la vitesse de conversion n'est limitée que par les performances de l'appareil local, sans attendre les allers-retours réseau. C'est particulièrement important lors du traitement de JSON contenant des clés API ou des champs métier non publiés.
Contrairement à certains outils en ligne qui lient de force les stratégies de décodage Codable / CodingKeys / Date, cet outil adhère à un principe de sortie minimale : les membres de l'équipe ont souvent des préférences différentes sur les protocoles, la nommage et le contrôle d'accès, et cet outil laisse les choix de protocoles et de stratégies aux développeurs pour les affiner par projet. Ce flux de travail « générer un semi-fini + traitement secondaire au niveau du projet » est généralement plus populaire auprès des ingénieurs dans les équipes moyennes et grandes que les solutions « tout en un clic ».
L'utilisation la plus courante dans les projets iOS / macOS : ajoutez Codable aux structs générés par cet outil, puis récupérez de manière asynchrone avec URLSession et décodez avec JSONDecoder.
import Foundation
// 1) Type racine généré par cet outil (avec protocole Codable ajouté)
struct User: Codable {
let id: Int
let name: String
let email: String
let isActive: Bool
let tags: [String]
}
// 2) Récupération et décodage asynchrones 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'utilisation (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)
}
}Lors de l'utilisation d'Alamofire, vous pouvez utiliser directement responseDecodable pour décoder automatiquement les structs générés par cet outil en objets Swift.
import Foundation
import Alamofire
// Type généré par cet outil, utilisable directement après ajout de 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 style 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 d'appel style Moya
// provider.request(.product(id: 1)).map(Product.self)
// let product: Product = try await provider.request(.product(id: 1)).map(Product.self)Dans les projets SwiftUI / Combine, vous pouvez utiliser les structs générés avec dataTaskPublisher / decode pour des flux de données réactifs.
import Foundation
import Combine
// Type racine généré par cet outil
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
}
/// Exposer le flux de données avec 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()
}
/// S'abonner dans 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?
}Collez votre contenu JSON dans la zone de saisie de gauche. Après un debounce de 400 ms, l'outil appelle automatiquement quicktype-core pour le convertir en code Swift et affiche le résultat dans le panneau de droite en temps réel. Vous pouvez également cliquer sur le bouton de téléversement pour sélectionner un fichier .json / .txt, ou cliquer sur le bouton d'exemple pour charger des données intégrées. Une fois la conversion terminée, vous pouvez copier le résultat ou le télécharger en tant que fichier .swift en un clic.
Par défaut, non. Cet outil utilise le mode just-types de quicktype-core, qui génère des déclarations de propriétés struct/class pures sans annotations Codable, Decodable ou Encodable, et sans instructions import. Si vous avez besoin de Codable, ajoutez simplement : Codable après génération (par ex. struct User: Codable {}), ou écrivez votre propre logique d'analyse avec JSONDecoder.
Tout JSON valide est pris en charge : types de base (null, boolean, number, string), tableaux unidimensionnels ou multidimensionnels et objets imbriqués de profondeur arbitraire. L'entrée racine peut être un objet JSON ou un tableau JSON ; l'outil priorise les objets et infère les tableaux par leur premier élément. Les entrées non prises en charge incluent les valeurs spéciales JavaScript (fonctions, Symbol, undefined) et le texte non-JSON.
L'outil génère récursivement des types Swift indépendants pour chaque objet imbriqué. Les noms sont basés sur une combinaison du nom du type parent et du nom du champ ; par exemple, si Root contient un champ address, un sous-type Address est généré, et le type principal le référence via var address: Address. Cela évite les définitions de types dupliquées et permet à l'autocomplétion et à la vérification de types de Xcode de suivre correctement les relations hiérarchiques.
Oui. Les tableaux JSON sont automatiquement convertis en forme [T] de Swift. Si les éléments du tableau sont des chaînes, [String] est généré ; si des entiers, [Int] ; si des nombres à virgule flottante, [Double] ; si des objets, [type personnalisé]. Les tableaux vides [] n'ont pas d'éléments d'exemple, donc [Any] est généré par défaut ; après génération, il est recommandé de le remplacer manuellement par un type concret comme [String] ou [Int].
Les valeurs null dans JSON ne peuvent pas avoir leur type concret inféré ; l'outil peut générer Any ou un type de secours. Il est recommandé de remplacer les champs avec une valeur null dans le JSON source par des valeurs d'exemple (par ex. "field": "" infère String) ou de les changer manuellement en Optional selon votre logique métier (par ex. var phone: String?), ce qui correspond mieux à la sémantique de sécurité du système de types de Swift.
Oui. Cliquez sur le bouton du nom de type (ou l'entrée des paramètres) dans la barre d'outils pour modifier le nom du type racine (la valeur par défaut est Root ou inférée à partir des données d'exemple). Les noms des sous-types sont générés automatiquement en fonction du nom racine et des noms de champs ; la règle de nommage est de capitaliser la première lettre du nom du champ, par ex. users → User, tags → Tag.
L'outil détecte automatiquement la validité du JSON ; en cas d'erreur, il affiche un message d'erreur spécifique à droite et fournit un bouton « Réparer JSON ». En cliquant dessus, les erreurs courantes sont automatiquement réparées : virgules finales, guillemets simples remplacés par des guillemets doubles, guillemets manquants sur les clés, suppression de commentaires, etc. Après une réparation réussie, vous pouvez continuer la conversion sans corriger manuellement le JSON.
Cela s'exécute entièrement dans votre navigateur. Toute l'analyse JSON et la génération de code Swift s'effectuent localement via JavaScript du navigateur (y compris quicktype-core dans un Web Worker) ; le JSON que vous saisissez et le code Swift généré ne sont jamais envoyés à un serveur, ni enregistrés ni mis en cache dans le cloud. Le JSON sensible contenant des clés API, des tokens, des champs de confidentialité utilisateur ou des structures métier non publiées peut être utilisé en toute sécurité — la fermeture de la page efface tout.
Oui. Le code généré est une syntaxe Swift standard et peut être directement copié dans un fichier .swift de Xcode, ou enregistré en tant que fichier .swift via le bouton « Télécharger » et glissé dans votre projet. Comme la sortie est des déclarations de types pures, il est recommandé d'ajouter manuellement des protocoles tels que Codable, Equatable, Identifiable selon les besoins, ou d'ajuster les modificateurs de contrôle d'accès (public / internal / private).
Oui. Lorsque l'entrée racine est un tableau JSON, l'outil utilise le premier élément du tableau comme modèle pour générer un type d'élément et génère la définition de ce type d'élément. Par exemple, [{"id":1,"name":"A"}] génère un struct nommé Item (ou un nom inféré à partir des champs) dont les champs sont ceux du premier élément ; le type principal le référence via une propriété items: [Item], évitant de traiter le tableau directement comme type racine.
Il n'y a pas de limite de taille explicite, mais le navigateur ralentira lors de l'analyse et du rendu de JSON très volumineux. Recommandations : ① Convertissez le JSON d'un seul module métier à la fois ; ② Divisez les niveaux d'imbrication profonds et traitez séparément ; ③ Pour le JSON de plus de quelques Mo, vous pouvez utiliser la version en ligne de commande de quicktype ; ④ Diviser le même JSON en plusieurs sous-modules et les convertir séparément peut réduire considérablement l'utilisation de la mémoire.
Les deux convertissent du JSON en définitions de types pour leurs langages respectifs, mais leur objectif diffère : JSON vers Swift génère des déclarations de propriétés struct/class pour les applications natives iOS/macOS ; JSON vers TypeScript génère des déclarations interface/type pour la vérification de types frontend. Si votre projet a à la fois un client iOS et un frontend Web, il est recommandé de générer les versions Swift et TS à partir du même JSON pour garantir la cohérence des types des deux côtés.
Cet outil génère des types purs par défaut sans protocoles. Après génération, il vous suffit d'ajouter : Codable après la déclaration struct/class, par ex. struct User: Codable {}, et JSONDecoder peut l'utiliser. Si vous voulez Codable par défaut, vous pouvez forker quicktype-core et modifier son moteur de rendu Swift, ou utiliser le remplacement par lot de Xcode pour ajouter le protocole à tous les types après génération.
La première visite nécessite Internet pour charger les scripts de l'outil et les ressources quicktype-core ; ensuite, il peut s'exécuter hors ligne depuis le cache du navigateur (dans un navigateur déjà visité). Les navigateurs mobiles (iOS Safari, Android Chrome) fonctionnent également normalement ; l'interface utilise une conception en écran partagé responsive qui passe automatiquement en empilement haut-bas en orientation portrait.
Oui. Après génération, chaque type Swift est un struct/class indépendant ; la sortie de l'outil est du texte brut. Vous pouvez copier individuellement un seul type et le coller dans Xcode, ou utiliser la refactorisation Rename de Xcode pour modifier par lots les types et les champs sans affecter les autres types. Si vous avez besoin de régénérer tout le groupe de types, actualisez simplement la page et collez à nouveau le JSON.
La prise en charge de quicktype pour les unions/enums nécessite des indications de type supplémentaires ou une entrée GraphQL/JSON Schema. Inférer des enums à partir de seuls échantillons JSON est difficile, donc cet outil ne génère pas d'enums par défaut. Si vous avez besoin d'enums, vous pouvez modifier manuellement le struct correspondant en enum + Codable, ou utiliser d'abord un outil JSON vers Kotlin/TypeScript pour obtenir des types enum puis les migrer manuellement vers Swift.
La zone de saisie de gauche est vide ou ne contient que des espaces. Collez du contenu JSON valide, ou cliquez sur « Exemple » pour charger un exemple, ou sur « Téléverser » pour sélectionner un fichier .json / .txt.
Le JSON est mal formé. Causes courantes : ① virgule finale (par ex. {"a":1,}) ; ② guillemets simples utilisés au lieu de guillemets doubles ; ③ syntaxe d'objet JS (par ex. {key: value}) au lieu de JSON (par ex. {"key": "value"}) ; ④ contient des commentaires JavaScript. En cliquant sur le bouton « Réparer JSON », certaines erreurs courantes peuvent être automatiquement réparées.
Ceci est le comportement attendu. Cet outil utilise le mode just-types et génère des déclarations de propriétés struct/class pures. Si vous avez besoin de Codable, ajoutez : Codable aux types après génération (par ex. struct User: Codable {}), ou écrivez extension User: Codable {} avant d'appeler JSONDecoder.
Les tableaux vides n'ont pas d'éléments d'exemple, donc l'outil génère le type de secours [Any]. Il est recommandé de placer au moins un élément d'exemple dans le JSON source (par ex. [1, 2]), de supprimer la valeur d'exemple après génération et de spécifier manuellement un type concret ; ou de passer directement à un type plus précis comme [String] / [User] après génération.
JSON null ne peut pas avoir son type concret inféré ; l'outil peut générer Any ou un type de secours. Il est recommandé de remplacer null dans le JSON source par une valeur d'exemple représentative (par ex. "" ou 0), puis de changer ce champ en Optional (?) ou un type concret après génération, par ex. var phone: String?.
Vous pouvez modifier le nom du type racine dans la barre d'outils ; les noms des sous-types sont générés automatiquement en fonction du nom racine + des noms de champs. Si vous n'êtes toujours pas satisfait, utilisez la refactorisation Rename de Xcode pour modifier par lots après génération (clic droit → Refactor → Rename) ; Xcode synchronisera les mises à jour de toutes les références.
Le navigateur ralentit lors du rendu de JSON très volumineux et de la génération de nombreux types. Il est recommandé de diviser le JSON en plusieurs modules métier indépendants et de convertir séparément, ou d'extraire uniquement les objets clés nécessitant une modélisation ; pour le JSON de plus de 10 Mo, nous recommandons la version en ligne de commande de quicktype.
Cela signifie que vous avez ajouté Codable à certains champs mais n'avez pas correctement géré les types Optional / Date / Enum. Corrections courantes : ① Passez tous les champs pouvant être null à Optional<T> ; ② Personnalisez la stratégie de dates avec JSONDecoder().dateDecodingStrategy = .iso8601 ; ③ Personnalisez CodingKeys pour aligner les clés JSON avec les noms de propriétés Swift.
Cet outil conserve les noms originaux des champs JSON par défaut, donc les champs snake_case sont générés tels quels. Si vous voulez unifier en camelCase, vous pouvez renommer par lots en utilisant Rename de Xcode après génération, ou convertir les noms de champs en camelCase dans un moteur de rendu quicktype personnalisé, puis ajouter des mappages CodingKeys pour assurer un décodage JSON correct.
Swift recommande des noms de champs comme identifiants ASCII en anglais. Si le JSON source contient des clés chinoises (par ex. {"姓名": "Alice"}), le var 姓名: String généré provoquera des erreurs du compilateur Swift dans certaines anciennes versions. Il est recommandé de modifier les clés en anglais (par ex. name) dans le JSON source, ce qui est plus conforme aux normes de codage Swift.
Cet outil génère des propriétés var public par défaut pour faciliter le post-traitement. Si vous voulez let ou un contrôle d'accès (par ex. private(set)), vous pouvez modifier par lots en utilisant Refactor de Xcode → Add Access Control, ou remplacer var par let en utilisant sed / un outil d'édition de texte après génération.
Cet outil mappe les chaînes ISO 8601 à String par défaut ; Swift ne les convertit pas automatiquement en Date. Vous devez définir dateDecodingStrategy dans JSONDecoder, par ex. JSONDecoder().dateDecodingStrategy = .iso8601. Si le format de date n'est pas standard, vous devrez également implémenter manuellement un DateFormatter ou une logique d'analyse personnalisée.
L'outil nomme les sous-types par « capitaliser la première lettre du nom de champ ». Le JSON profondément imbriqué peut avoir des objets imbriqués portant le même nom et causer des conflits de types. Solutions : ① Ajoutez des préfixes métier aux champs dans le JSON source ; ② Divisez le JSON racine en plusieurs modules indépendants et générez séparément ; ③ Utilisez Rename de Xcode pour modifier par lots les noms de types en conflit après génération.
Cet outil génère internal struct par défaut sans modificateur public explicite. Si votre projet est divisé par modules et nécessite un accès inter-modules, vous devez remplacer par lots struct par public struct dans Xcode, ou ajouter uniformément le mot-clé public à l'aide de scripts sed/awk après génération.
L'outil infère automatiquement les types Swift correspondants en fonction de la forme des valeurs JSON :
| Exemple de valeur JSON | Méthode de détection | Type Swift généré | Notes |
|---|---|---|---|
null | value === null | Any? ou Optional concret | Impossible d'inférer un type concret ; recommandez de passer manuellement à Optional<T> après génération |
true / false | typeof value === 'boolean' | Bool | Mappé directement au type Bool de Swift |
42 | typeof value === 'number' && Number.isInteger(value) | Int | Les entiers sont mappés à Int (32/64 bits déterminé par la plateforme) |
3.14 | typeof value === 'number' && !Number.isInteger(value) | Double | Les nombres à virgule flottante sont mappés à Double |
"hello" | typeof value === 'string' | String | Les chaînes sont mappées à String |
[] (tableau vide) | Array.isArray(value) && value.length === 0 | [Any] | Impossible d'inférer le type d'élément ; recommandez d'ajouter un exemple ou de passer manuellement à un type concret |
["a", "b"] | Array.isArray(value) && typeof value[0] === 'string' | [String] | Tableau de chaînes |
[1, 2, 3] | Array.isArray(value) && typeof value[0] === 'number' | [Int] | Tableau d'entiers |
[1.5, 2.5] | Array.isArray(value) && typeof value[0] === 'number' && !Number.isInteger(value[0]) | [Double] | Tableau de flottants |
[{...}, {...}] | Array.isArray(value) && typeof value[0] === 'object' | [Item] | Tableau d'objets, les éléments sont des types personnalisés, noms inférés des noms de champs |
{...} (objet imbriqué) | typeof value === 'object' && !Array.isArray(value) | struct / class indépendant | Génère récursivement des types indépendants, nommés en capitalisant les noms de champs |
Les types Swift générés peuvent être utilisés directement dans différents scénarios sur les plateformes Apple / frameworks tiers :
| Cas d'utilisation | Frameworks courants | Protocole / Traitement à ajouter | Fragment de code typique |
|---|---|---|---|
Analyse d'API REST | URLSession + JSONDecoder | Ajoutez Codable aux types, conservez la sémantique de valeur struct | try JSONDecoder().decode(User.self, from: data) |
Requêtes HTTP simplifiées | Alamofire | Ajoutez Codable aux types, utilisez avec responseDecodable | session.request(url).responseDecodable(of: User.self) |
Couche réseau abstraite | Moya | Ajoutez Codable aux types ; Moya désérialise automatiquement | provider.request(.user(id: 1)).map(User.self) |
Flux de données réactifs | Combine + JSONDecoder | Ajoutez Codable aux types, combinez avec dataTaskPublisher | URLSession.shared.dataTaskPublisher(for: url).decode(type: User.self, decoder: decoder) |
Affichage de listes SwiftUI | SwiftUI List + Identifiable | Ajoutez Identifiable aux types pour le forEach automatique de List | List(items) { Text($0.name) } |
Définition de modèles serveur | Vapor | Ajoutez Codable aux types ; sérialisation Content automatique de Vapor | struct User: Codable, Content { var id: Int; var name: String } |
Modèle de persistance locale | SwiftData / Core Data | Ajoutez @Model / @NSManaged sur les struct / class générés | @Model class User { var id: Int; var name: String } |
Partage de types multiplateforme | JSON vers Swift + JSON vers TypeScript combinés | Conservez la cohérence des noms de champs Swift et TS ; le côté TS utilise les types TS | Swift: var name: String / TS: name: string |
Cet outil JSON vers Swift effectue toutes les opérations d'analyse JSON et de génération de types Swift entièrement dans votre navigateur via JavaScript (quicktype-core / Web Worker). Les données JSON que vous saisissez et le code Swift généré ne sont jamais envoyés à un serveur, ni enregistrés, mis en cache ou stockés dans le cloud. Le JSON sensible contenant des champs d'API internes, des clés API, des tokens, des données de confidentialité utilisateur ou des structures métier non publiées peut être utilisé en toute sécurité ; tout le contenu d'entrée et de sortie est automatiquement effacé de la mémoire lorsque vous fermez ou actualisez la page, sans dépendre de services réseau tiers.