quicktype

quicktype genera serializadores y modelos fuertemente tipados a partir de consultas JSON, JSON Schema, TypeScript y GraphQL, lo que facilita trabajar con tipos JSON de forma segura en muchos lenguajes de programación.

• Pruebe quicktype en su navegador.
• Lea 'Un primer vistazo a QuickType' para obtener más información.
• Si tiene alguna pregunta, consulte primero las preguntas frecuentes.

Entradas admitidas

JSON	URL de API JSON	Esquema JSON

Mecanografiado	Consultas GraphQL

Idiomas de destino

Rubí	javascript	Fluir	Óxido	Kotlin

Dardo	Pitón	DO#	Ir	C++

Java	escala	Mecanografiado	Rápido	Objetivo-C	Olmo

Esquema JSON	Lucio	Tipos de accesorios	Haskell	PHP

¿Echas de menos tu idioma favorito? ¡Por favor implementelo!

Instalación

Hay muchas formas de utilizar quicktype . app.quicktype.io es la interfaz de usuario más potente y completa. La aplicación web también funciona sin conexión y no envía sus datos de muestra a través de Internet, ¡así que péguelos!

Para obtener la mejor CLI, recomendamos instalar quicktype globalmente a través de npm :

npm install -g quicktype

Usando 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

Generando código a partir del esquema JSON

La forma recomendada de utilizar quicktype es generar un esquema JSON a partir de datos de muestra, revisar y editar el esquema, enviar el esquema al repositorio de su proyecto y luego generar código a partir del esquema como parte de su proceso de compilación:

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

Generando código desde TypeScript (Experimental)

Puede lograr un resultado similar escribiendo o generando un archivo TypeScript y luego escribiéndolo rápidamente. TypeScript es un superconjunto escrito de JavaScript con una sintaxis simple y concisa para definir tipos:

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

Puede usar TypeScript tal como se usó el esquema JSON en el último ejemplo:

 # 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

Llamar quicktype desde JavaScript

Puede utilizar quicktype como función de JavaScript dentro node o los navegadores. Primero agregue el paquete quicktype-core :

$ npm install quicktype-core

En general, primero crea un valor InputData con uno o más ejemplos JSON, esquemas JSON, fuentes TypeScript u otros tipos de entrada admitidos. Luego llamas quicktype y pasas ese valor InputData y las opciones que desees.

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

El argumento de quicktype es un objeto complejo con muchas propiedades opcionales. Explore su definición para comprender qué opciones están permitidas.

Contribuyendo

quicktype es de código abierto y nos encantan los contribuyentes! De hecho, tenemos una lista de cuestiones que para nosotros son de baja prioridad, pero para las cuales aceptaríamos con gusto contribuciones. También se desea encarecidamente la compatibilidad con nuevos idiomas de destino. Si desea contribuir, necesita ayuda con cualquier cosa o simplemente desea hablar sobre el tema, únase a nosotros en Slack.

Configurar, construir, ejecutar

quicktype se implementa en TypeScript y requiere nodejs y npm para compilarse y ejecutarse.

Primero, instale typescript globalmente a través de npm :

Clona este repositorio y haz:

macOS/Linux

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

ventanas

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

Editar

Instale Visual Studio Code, abra este espacio de trabajo e instale las extensiones recomendadas:

code . # opens in VS Code

Recarga en vivo para comentarios rápidos

Cuando trabaje en un idioma de salida, querrá ver el resultado generado a medida que edita. Utilice npm start para observar los cambios y volver a compilar y ejecutar quicktype para obtener comentarios en vivo. Por ejemplo, si está desarrollando un nuevo renderizador para fortran , puede usar el siguiente comando para reconstruir y reinvocar quicktype a medida que implementa su renderizador:

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

El comando entre comillas se pasa a quicktype , por lo que puede representar archivos .json locales, URL o agregar otras opciones.

Prueba

 # 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