quicktype

quicktype gera modelos e serializadores fortemente tipados a partir de consultas JSON, JSON Schema, TypeScript e GraphQL, facilitando o trabalho com segurança de digitação JSON em muitas linguagens de programação.

• Experimente quicktype no seu navegador.
• Leia 'Uma primeira olhada no quicktype' para obter mais informações.
• Se você tiver alguma dúvida, verifique primeiro o FAQ.

Entradas suportadas

JSON	URLs da API JSON	Esquema JSON

Texto datilografado	Consultas GraphQL

Idiomas alvo

Rubi	JavaScript	Fluxo	Ferrugem	Kotlin

Dardo	Pitão	C#	Ir	C++

Java	escala	Texto datilografado	Rápido	Objetivo-C	Olmo

Esquema JSON	Pique	Tipos de acessórios	Haskell	PHP

Sentindo falta do seu idioma favorito? Por favor, implemente-o!

Instalação

Existem muitas maneiras de usar quicktype . app.quicktype.io é a UI mais poderosa e completa. O aplicativo da web também funciona offline e não envia seus dados de amostra pela Internet, então cole!

Para obter a melhor CLI, recomendamos instalar quicktype globalmente via 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

Gerando código do esquema JSON

A maneira recomendada de usar quicktype é gerar um esquema JSON a partir de dados de amostra, revisar e editar o esquema, confirmar o esquema no repositório do projeto e, em seguida, gerar o código do esquema como parte do processo de construção:

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

Gerando código do TypeScript (Experimental)

Você pode obter um resultado semelhante escrevendo ou gerando um arquivo TypeScript e digitando-o rapidamente. TypeScript é um superconjunto digitado de JavaScript com sintaxe simples e sucinta para definir tipos:

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

Você pode usar TypeScript assim como o esquema JSON foi usado no último exemplo:

 # 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

Chamando quicktype de JavaScript

Você pode usar quicktype como uma função JavaScript em node ou navegadores. Primeiro adicione o pacote quicktype-core :

$ npm install quicktype-core

Em geral, primeiro você cria um valor InputData com uma ou mais amostras JSON, esquemas JSON, fontes TypeScript ou outros tipos de entrada compatíveis. Então você chama quicktype , passando o valor InputData e as opções desejadas.

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

O argumento para quicktype é um objeto complexo com muitas propriedades opcionais. Explore sua definição para entender quais opções são permitidas.

Contribuindo

quicktype é Open Source e adoramos colaboradores! Na verdade, temos uma lista de questões que são de baixa prioridade para nós, mas para as quais aceitaríamos contribuições com prazer. O suporte para novos idiomas de destino também é fortemente desejado. Se você quiser contribuir, precisar de ajuda com alguma coisa ou apenas quiser conversar sobre o assunto, junte-se a nós no Slack.

Configurar, construir, executar

quicktype é implementado em TypeScript e requer nodejs e npm para construir e executar.

Primeiro, instale typescript globalmente via npm :

Clone este repositório e faça:

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

Editar

Instale o Visual Studio Code, abra este espaço de trabalho e instale as extensões recomendadas:

code . # opens in VS Code

Recarregamento ao vivo para feedback rápido

Ao trabalhar em um idioma de saída, você desejará visualizar a saída gerada enquanto edita. Use npm start para observar alterações e recompilar e executar novamente quicktype para obter feedback ao vivo. Por exemplo, se você estiver desenvolvendo um novo renderizador para fortran , poderá usar o seguinte comando para reconstruir e invocar novamente quicktype ao implementar seu renderizador:

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

O comando entre aspas é passado para quicktype , para que você possa renderizar arquivos .json locais, URLs ou adicionar outras opções.

Teste

 # 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