Online generátor JSON na JSON schému

Ako proces vygenerovania schémy funguje

Vytváranie JSON schémy zo vzorového JSON-u je viac než len mapovanie polí na typy. Tento nástroj využíva niekoľko kľúčových krokov pre správnosť a úplnosť:

1. Parsovanie: Nástroj analyzuje váš JSON podľa ECMA-404 a hlási podrobné chyby pri nesprávnom formáte alebo nejasnostiach.
2. Štrukturálna analýza: Vytvára stromovú reprezentáciu vašich dát, klasifikujúc každú vlastnosť a prvok podľa základných typov JSON schémy (objekt, pole, reťazec, číslo, celé číslo, boolean, null).
3. Rekurzívny prechod: Hlboké a vnorené štruktúry – vrátane polí objektov či vnorených polí – sú rekurzívne prechádzané na vytvorenie vnorených definícií schémy.
4. Inferencia a zlúčenie typov: Pre každú vlastnosť alebo prvok poľa sú odhadnuté typy. Pri miešaných typoch je 'type' vyjadrený ako pole (union type), v súlade s JSON schémou.
5. Detekcia povinných a nepovinných: Analyzovaním všetkých objektov na každej úrovni nástroj rozlišuje vždy prítomné (povinné) a niekedy chýbajúce (nepovinné) kľúče.
6. Obmedzenia hodnôt: Nástroj odvodzuje možné enumerácie (súbor povolených hodnôt), min/max pre čísla, minLength/maxLength pre reťazce a formátové indikátory (ako 'email', 'uri' alebo 'date-time').
7. Spracovanie hraničných prípadov: Špeciálna pozornosť je venovaná prázdnym poliam, null hodnotám a riedkym štruktúram, čo zaručuje platné schémy zodpovedajúce reálnej variabilite.
8. Syntéza schémy: Výsledná schéma je vydaná ako štandardné, kompatibilné s Draft-07, pripravená na použitie v nástrojoch ako Ajv, OpenAPI alebo knižniciach na generovanie kódu.

Prečo generovať JSON schému? Praktické využitie

• Automatická validácia: Používajte vygenerované schémy na presadzovanie dátových zmlúv a validáciu prichádzajúcich dát v API, mikroslužbách alebo príkazových riadkoch.
• Dokumentácia API: Automaticky generujte dokumentáciu a interaktívne prehliadače (Swagger, Postman) s presnými definíciami dát.
• Generovanie kódu: Vytvárajte typovo bezpečné modely alebo validátory v TypeScript, Pythone, Jave a iných jazykoch so schémou ako jediným zdrojom pravdy.
• Generovanie testovacích dát: Nástroje ako JSON Schema Faker alebo Mockaroo využívajú schémy na syntézu realistických testovacích dát pre QA a záťažové testy.
• Refaktoring a migrácia: Validujte staré alebo menené dátové štruktúry, zabezpečujúc kompatibilitu počas vývoja backendu.

Technické funkcie

• Kompatibilita s Draft-07 pre maximálnu interoperabilitu s hlavnými validátormi a platformami na návrh API.
• Rekurzívna analýza ľubovoľnej hĺbky vnorenia – polia v poliach, objekty v poliach a ďalšie.
• Presná inferencia združovacích typov ('type' pole) pre polia alebo položky, ktoré sa líšia medzi vzorkami.
• Automatická detekcia enumerácií, dĺžok, vzorov, formátov, min/max a iných bežných obmedzení.
• Explicitná podpora null hodnôt, prázdnych polí/objektov a čiastočných záznamov.
• Generovanie schémy prebieha kompletne v prehliadači. Váš vstupný JSON nikdy neopúšťa vaše zariadenie.

Technický príklad: Od vzorového JSON k Draft-07 schéme

{
  "transaction": {
    "id": "txn_abc123",
    "amount": 99.95,
    "currency": "USD",
    "status": "completed",
    "meta": {
      "ip": "203.0.113.1",
      "tags": ["recurring", null]
    }
  },
  "refunded": false,
  "notes": null
}

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "transaction": {
      "type": "object",
      "properties": {
        "id": { "type": "string" },
        "amount": { "type": "number" },
        "currency": { "type": "string", "minLength": 3, "maxLength": 3 },
        "status": { "type": "string", "enum": ["completed"] },
        "meta": {
          "type": "object",
          "properties": {
            "ip": { "type": "string", "format": "ipv4" },
            "tags": {
              "type": "array",
              "items": { "type": ["string", "null"] }
            }
          },
          "required": ["ip", "tags"]
        }
      },
      "required": ["id", "amount", "currency", "status", "meta"]
    },
    "refunded": { "type": "boolean" },
    "notes": { "type": ["null"] }
  },
  "required": ["transaction", "refunded", "notes"]
}

Ako používať tento nástroj JSON na JSON schému

1. Vložte alebo napíšte svoj ukážkový JSON do editora nižšie. Nástroj prijíma akýkoľvek platný JSON, od jednoduchých objektov po hlboko vnorené štruktúry.
2. Kliknite na 'Vygenerovať JSON schému' pre vytvorenie a zobrazenie vygenerovanej JSON schémy.
3. Skopírujte, upravte alebo stiahnite schému. Integrujte ju priamo do definícií API, validačnej logiky alebo dokumentácie.

Príklady kódu na generovanie schém z JSON

Pozrite sa, ako vygenerovať JSON schému z JSON v rôznych programovacích jazykoch.

const generateSchema = require('jsonschema-generator');
const data = {
  name: "Alice",
  age: 30,
  isActive: true,
  tags: ["user", "admin"]
};
const schema = generateSchema(data);
console.log(JSON.stringify(schema, null, 2));

const GenerateSchema = require('generate-schema');
const data = { name: "Alice", age: 30, tags: ["admin", "user"] };
const schema = GenerateSchema.json('User', data);
console.log(JSON.stringify(schema, null, 2));

from genson import SchemaBuilder
sample = {"name": "Alice", "age": 30, "tags": ["user", "admin"]}
builder = SchemaBuilder()
builder.add_object(sample)
print(builder.to_json(indent=2))

from jsonschema_generate import generate_schema
sample = {"name": "Alice", "age": 30, "tags": ["user", "admin"]}
schema = generate_schema(sample)
print(schema)

package main
import (
  "encoding/json"
  "fmt"
  "github.com/invopop/jsonschema"
)
type User struct {
  Name string   `json:"name"
  Age  int      `json:"age"
  Tags []string `json:"tags"
}
func main() {
  schema := jsonschema.Reflect(&User{})
  out, _ := json.MarshalIndent(schema, "", "  ")
  fmt.Println(string(out))
}

# Generate Java POJOs *from* a JSON Schema, not the reverse.
# For schema generation from Java, see tools like jackson-module-jsonSchema.
# See: https://github.com/FasterXML/jackson-module-jsonSchema

using NJsonSchema;
using Newtonsoft.Json.Linq;
var sample = JObject.Parse("{\"name\":\"Alice\",\"age\":30, \"tags\":[\"user\"]}");
var schema = await JsonSchema.FromSampleJsonAsync(sample.ToString());
Console.WriteLine(schema.ToJson());

require 'vendor/autoload.php';
use Swaggest\JsonSchema\Structure\ClassStructure;
$sample = ["name" => "Alice", "age" => 30, "tags" => ["user"]];
$schema = ClassStructure::exportSchema($sample);
echo json_encode($schema, JSON_PRETTY_PRINT);

require 'json_schemer'
sample = { "name" => "Alice", "age" => 30, "tags" => ["admin", "user"] }
schema = JSONSchemer.schema(sample)
puts schema.to_json

echo '{"name":"Alice","age":30,"tags":["user","admin"]}' | genson | jq .

use schemars::JsonSchema;
use serde::Serialize;
#[derive(Serialize, JsonSchema)]
struct User {
  name: String,
  age: u32,
  tags: Vec<String>,
}
fn main() {
  let schema = schemars::schema_for!(User);
  println!("{}", serde_json::to_string_pretty(&schema).unwrap());
}

import json.schema._
case class User(name: String, age: Int, tags: List[String])
val schema = Json.schema[User]
println(schema.asSpray.prettyPrint)

# Generate schema from a TypeScript interface:
typescript-json-schema tsconfig.json User --out schema.json
# See https://github.com/YousefED/typescript-json-schema

// Dart does not have an automatic JSON Schema generator yet.
// Manually define schema as a Dart Map or use online tools.