quicktype

quicktype génère des modèles et des sérialiseurs fortement typés à partir de requêtes JSON, JSON Schema, TypeScript et GraphQL, ce qui facilite grandement le travail avec le type JSON en toute sécurité dans de nombreux langages de programmation.

• Essayez quicktype dans votre navigateur.
• Lisez « Un premier aperçu de quicktype » pour plus d'introduction.
• Si vous avez des questions, consultez d'abord la FAQ.

Entrées prises en charge

JSON	URL d'API JSON	Schéma JSON

Manuscrit	Requêtes GraphQL

Langues cibles

Rubis	Javascript	Couler	Rouiller	Kotlin

Dard	Python	C#	Aller	C++

Java	Échelle	Manuscrit	Rapide	Objectif-C	Orme

Schéma JSON	Brochet	Types d'accessoires	Haskell	PHP

Votre langue préférée vous manque ? S'il vous plaît, mettez-le en œuvre !

Installation

Il existe de nombreuses façons d’utiliser quicktype . app.quicktype.io est l'interface utilisateur la plus puissante et la plus complète. L'application Web fonctionne également hors ligne et n'envoie pas vos exemples de données sur Internet, alors collez-les !

Pour la meilleure CLI, nous vous recommandons d'installer quicktype globalement via npm :

npm install -g quicktype

Utiliser quicktype

 # Run quicktype without arguments for help and options
quicktype

# quicktype a simple JSON object in C#
echo ' { "name": "David" } ' | quicktype -l csharp

# quicktype a top-level array and save as Go source
echo ' [1, 2, 3] ' | quicktype -o ints.go

# quicktype a sample JSON file in Swift
quicktype person.json -o Person.swift

# A verbose way to do the same thing
quicktype 
  --src person.json 
  --src-lang json 
  --lang swift 
  --top-level Person 
  --out Person.swift

# quicktype a directory of samples as a C++ program
# Suppose ./blockchain is a directory with files:
#   latest-block.json transactions.json marketcap.json
quicktype ./blockchain -o blockchain-api.cpp

# quicktype a live JSON API as a Java program
quicktype https://api.somewhere.com/data -o Data.java

Générer du code à partir du schéma JSON

La méthode recommandée pour utiliser quicktype consiste à générer un schéma JSON à partir d'exemples de données, à examiner et à modifier le schéma, à valider le schéma dans le référentiel de votre projet, puis à générer du code à partir du schéma dans le cadre de votre processus de génération :

 # First, infer a JSON schema from a sample.
quicktype pokedex.json -l schema -o schema.json

# Review the schema, make changes,
# and commit it to your project repo.

# Finally, generate model code from schema in your
# build process for whatever languages you need:
quicktype -s schema schema.json -o src/ios/models.swift
quicktype -s schema schema.json -o src/android/Models.java
quicktype -s schema schema.json -o src/nodejs/Models.ts

# All of these models will serialize to and from the same
# JSON, so different programs in your stack can communicate
# seamlessly.

Génération de code à partir de TypeScript (expérimental)

Vous pouvez obtenir un résultat similaire en écrivant ou en générant un fichier TypeScript, puis en le saisissant rapidement. TypeScript est un sur-ensemble typé de JavaScript avec une syntaxe simple et succincte pour définir les types :

 interface Person {
    name : string ;
    nickname ?: string ; // an optional property
    luckyNumber : number ;
}

Vous pouvez utiliser TypeScript tout comme le schéma JSON a été utilisé dans le dernier exemple :

 # First, infer a TypeScript file from a sample (or just write one!)
quicktype pokedex.json -o pokedex.ts --just-types
# Review the TypeScript, make changes, etc.
quicktype pokedex.ts -o src/ios/models.swift

Appel de quicktype depuis JavaScript

Vous pouvez utiliser quicktype comme fonction JavaScript dans node ou un navigateur. Ajoutez d’abord le package quicktype-core :

$ npm install quicktype-core

En général, vous créez d’abord une valeur InputData avec un ou plusieurs échantillons JSON, schémas JSON, sources TypeScript ou autres types d’entrée pris en charge. Ensuite, vous appelez quicktype , en transmettant cette valeur InputData et toutes les options souhaitées.

 import {
    quicktype ,
    InputData ,
    jsonInputForTargetLanguage ,
    JSONSchemaInput ,
    FetchingJSONSchemaStore
} from "quicktype-core" ;

async function quicktypeJSON ( targetLanguage , typeName , jsonString ) {
    const jsonInput = jsonInputForTargetLanguage ( targetLanguage ) ;

    // We could add multiple samples for the same desired
    // type, or many sources for other types. Here we're
    // just making one type from one piece of sample JSON.
    await jsonInput . addSource ( {
        name : typeName ,
        samples : [ jsonString ]
    } ) ;

    const inputData = new InputData ( ) ;
    inputData . addInput ( jsonInput ) ;

    return await quicktype ( {
        inputData ,
        lang : targetLanguage
    } ) ;
}

async function quicktypeJSONSchema ( targetLanguage , typeName , jsonSchemaString ) {
    const schemaInput = new JSONSchemaInput ( new FetchingJSONSchemaStore ( ) ) ;

    // We could add multiple schemas for multiple types,
    // but here we're just making one type from JSON schema.
    await schemaInput . addSource ( { name : typeName , schema : jsonSchemaString } ) ;

    const inputData = new InputData ( ) ;
    inputData . addInput ( schemaInput ) ;

    return await quicktype ( {
        inputData ,
        lang : targetLanguage
    } ) ;
}

async function main ( ) {
    const { lines : swiftPerson } = await quicktypeJSON ( "swift" , "Person" , jsonString ) ;
    console . log ( swiftPerson . join ( "n" ) ) ;

    const { lines : pythonPerson } = await quicktypeJSONSchema ( "python" , "Person" , jsonSchemaString ) ;
    console . log ( pythonPerson . join ( "n" ) ) ;
}

main ( ) ;

L'argument de quicktype est un objet complexe avec de nombreuses propriétés facultatives. Explorez sa définition pour comprendre quelles options sont autorisées.

Contribuer

quicktype est Open Source et nous aimons les contributeurs ! En fait, nous avons une liste de questions qui ne sont pas prioritaires pour nous, mais pour lesquelles nous accepterions volontiers des contributions. La prise en charge de nouvelles langues cibles est également fortement souhaitée. Si vous souhaitez contribuer, avez besoin d'aide pour quoi que ce soit ou si vous souhaitez simplement en discuter, rejoignez-nous sur Slack.

Installer, construire, exécuter

quicktype est implémenté dans TypeScript et nécessite nodejs et npm pour être construit et exécuté.

Tout d’abord, installez typescript globalement via npm :

Clonez ce dépôt et faites :

macOS/Linux

nvm use
npm install
script/quicktype # rebuild (slow) and run (fast) 

Fenêtres

npm install --ignore-scripts # Install dependencies
npm install -g typescript # Install typescript globally
tsc --project src/cli # Rebuild
node dist c li i ndex.js # Run

Modifier

Installez Visual Studio Code, ouvrez cet espace de travail et installez les extensions recommandées :

code . # opens in VS Code

Rechargement en direct pour un retour rapide

Lorsque vous travaillez sur une langue de sortie, vous souhaiterez afficher la sortie générée au fur et à mesure que vous la modifiez. Utilisez npm start pour surveiller les modifications, recompiler et réexécuter quicktype pour obtenir des commentaires en direct. Par exemple, si vous développez un nouveau moteur de rendu pour fortran , vous pouvez utiliser la commande suivante pour reconstruire et réinvoquer quicktype lorsque vous implémentez votre moteur de rendu :

npm start -- " --lang fortran pokedex.json "

La commande entre guillemets est transmise à quicktype , vous pouvez donc restituer les fichiers .json locaux, les URL ou ajouter d'autres options.

Test

 # Run full test suite
npm run test

# Test a specific language (see test/languages.ts)
FIXTURE=golang npm test

# Test a single sample or directory
FIXTURE=swift npm test -- pokedex.json
FIXTURE=swift npm test -- test/inputs/json/samples