quicktype

quicktype generiert stark typisierte Modelle und Serialisierer aus JSON-, JSON-Schema-, TypeScript- und GraphQL-Abfragen, sodass die typsichere Arbeit mit JSON in vielen Programmiersprachen zum Kinderspiel wird.

• Probieren Sie quicktype in Ihrem Browser aus.
• Weitere Informationen finden Sie unter „Ein erster Blick auf Quicktype“.
• Wenn Sie Fragen haben, schauen Sie sich zuerst die FAQ an.

Unterstützte Eingaben

JSON	JSON-API-URLs	JSON-Schema

Typoskript	GraphQL-Abfragen

Zielsprachen

Rubin	JavaScript	Fließen	Rost	Kotlin

Pfeil	Python	C#	Gehen	C++

Java	Scala	Typoskript	Schnell	Ziel-C	Ulme

JSON-Schema	Pike	Requisitentypen	Haskell	PHP

Vermissen Sie Ihre Lieblingssprache? Bitte umsetzen!

Installation

Es gibt viele Möglichkeiten, quicktype zu verwenden. app.quicktype.io ist die leistungsstärkste und umfassendste Benutzeroberfläche. Die Web-App funktioniert auch offline und sendet Ihre Beispieldaten nicht über das Internet, also los!

Für die beste CLI empfehlen wir die globale Installation quicktype über npm :

npm install -g quicktype

quicktype verwenden

 # 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

Code aus JSON-Schema generieren

Die empfohlene Methode zur Verwendung quicktype besteht darin, ein JSON-Schema aus Beispieldaten zu generieren, das Schema zu überprüfen und zu bearbeiten, das Schema in Ihr Projekt-Repository zu übernehmen und dann im Rahmen Ihres Build-Prozesses Code aus dem Schema zu generieren:

 # 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.

Generieren von Code aus TypeScript (experimentell)

Sie können ein ähnliches Ergebnis erzielen, indem Sie eine TypeScript-Datei schreiben oder generieren und diese dann schnell eingeben. TypeScript ist eine typisierte Obermenge von JavaScript mit einfacher, prägnanter Syntax zum Definieren von Typen:

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

Sie können TypeScript genauso verwenden, wie das JSON-Schema im letzten Beispiel verwendet wurde:

 # 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

Aufruf quicktype aus JavaScript

Sie können quicktype als JavaScript-Funktion innerhalb von node oder Browsern verwenden. Fügen Sie zunächst das quicktype-core Paket hinzu:

$ npm install quicktype-core

Im Allgemeinen erstellen Sie zunächst einen InputData Wert mit einem oder mehreren JSON-Beispielen, JSON-Schemas, TypeScript-Quellen oder anderen unterstützten Eingabetypen. Dann rufen Sie quicktype auf und übergeben den InputData Wert und alle gewünschten Optionen.

 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 ( ) ;

Das Argument für quicktype ist ein komplexes Objekt mit vielen optionalen Eigenschaften. Erkunden Sie die Definition, um zu verstehen, welche Optionen zulässig sind.

Mitwirken

quicktype ist Open Source und wir lieben Mitwirkende! Tatsächlich haben wir eine Liste von Themen, die für uns eine niedrige Priorität haben, zu denen wir aber gerne Beiträge annehmen würden. Auch die Unterstützung neuer Zielsprachen ist dringend erwünscht. Wenn Sie einen Beitrag leisten möchten, bei irgendetwas Hilfe benötigen oder einfach nur Dinge besprechen möchten, kommen Sie zu uns auf Slack.

Einrichten, erstellen, ausführen

quicktype ist in TypeScript implementiert und erfordert zum Erstellen und Ausführen nodejs und npm .

Installieren Sie typescript zunächst global über npm :

Klonen Sie dieses Repo und führen Sie Folgendes aus:

macOS / Linux

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

Windows

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

Bearbeiten

Installieren Sie Visual Studio Code, öffnen Sie diesen Arbeitsbereich und installieren Sie die empfohlenen Erweiterungen:

code . # opens in VS Code

Live-Nachladen für schnelles Feedback

Wenn Sie an einer Ausgabesprache arbeiten, möchten Sie während der Bearbeitung die generierte Ausgabe anzeigen. Verwenden Sie npm start um auf Änderungen zu achten, und kompilieren Sie quicktype neu und führen Sie es erneut aus, um Live-Feedback zu erhalten. Wenn Sie beispielsweise einen neuen Renderer für fortran entwickeln, können Sie den folgenden Befehl verwenden, um quicktype neu zu erstellen und erneut aufzurufen, während Sie Ihren Renderer implementieren:

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

Der Befehl in Anführungszeichen wird an quicktype übergeben, sodass Sie lokale .json Dateien und URLs rendern oder andere Optionen hinzufügen können.

Prüfen

 # 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