Online JSON naar JSON Schema Generator

Hoe Schema Generatie Werkt Achter de Schermen

Het genereren van JSON Schema uit voorbeeld JSON omvat meer dan velden aan typen koppelen. Deze tool volgt meerdere belangrijke stappen voor correctheid en volledigheid:

1. Parseren: De tool parseert je JSON volgens ECMA-404 en geeft gedetailleerde foutenrapportages bij onjuiste invoer of onduidelijke constructies.
2. Structurele Analyse: Er wordt een boomstructuur van je data gebouwd, waarbij elke eigenschap en element wordt geclassificeerd volgens de kern-typen van JSON Schema (object, array, string, number, integer, boolean, null).
3. Recursieve Traversal: Diepe en geneste structuren—zoals arrays van objecten of geneste arrays—worden recursief doorlopen om geneste schema definities te genereren.
4. Type Afleiding en Samenvoeging: Voor elke eigenschap of array-element worden typen afgeleid. Bij gemengde typen wordt 'type' als array (unietype) volgens JSON Schema specificatie weergegeven.
5. Detectie Verplicht vs. Optioneel: Door alle objecten op elk niveau te analyseren, onderscheidt de tool altijd aanwezige (verplicht) en soms afwezige (optionele) sleutels.
6. Waarde-Beperkingen: Waar mogelijk worden enums (toegestane waardeset), min/max voor getallen, minLength/maxLength voor strings, en format hints (zoals 'email', 'uri' of 'date-time') afgeleid.
7. Afhandeling Uitzonderingen: Speciale aandacht voor lege arrays, nulls en verspreide structuren—voor geldige schema's die aansluiten bij praktijkvariabiliteit.
8. Schema Synthese: Het uiteindelijke schema wordt uitgegeven als een standaardconform Draft-07 document—klaar voor gebruik met tools zoals Ajv, OpenAPI of codegeneratie bibliotheken.

Waarom JSON Schema Genereren? Praktische Toepassingen

• Automatische Validatie: Gebruik gegenereerde schema's om datacontracten af te dwingen en inkomende payloads in API's, microservices of CLI's te valideren.
• API Documentatie: Genereer automatisch documentatie en interactieve verkenners (Swagger, Postman) met nauwkeurige datadefinities.
• Codegeneratie: Maak type-veilige modellen of validators in TypeScript, Python, Java en andere talen met je schema als enkele bron van waarheid.
• Testdata Generatie: Tools zoals JSON Schema Faker of Mockaroo gebruiken schema's om realistische mockdata te synthetiseren voor QA en load testen.
• Refactoring & Migratie: Valideer legacy of veranderende datastructuren en zorg voor compatibiliteit terwijl je backend evolueert.

Technische Kenmerken

• Draft-07 compatibiliteit voor maximale interoperabiliteit met grote validators en API-ontwerpplatforms.
• Recursieve analyse van elke nestingsdiepte—arrays binnen arrays, objecten binnen arrays, en meer.
• Nauwkeurige unietype ('type' array) afleiding voor velden of items die per voorbeeld verschillen.
• Automatische detectie van enums, lengte, patroon, formaat, min/max, en andere veelvoorkomende beperkingen.
• Explisite ondersteuning voor nulls, lege arrays/objecten en gedeeltelijke records.
• Schema generatie vindt volledig lokaal in je browser plaats. Je JSON-invoer verlaat je apparaat nooit.

Technisch Voorbeeld: Van JSON Voorbeeld naar Draft-07 Schema

{
  "transaction": {
    "id": "txn_abc123",
    "amount": 99.95,
    "currency": "USD",
    "status": "voltooid",
    "meta": {
      "ip": "203.0.113.1",
      "tags": ["terugkerend", 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": ["voltooid"] },
        "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"]
}

Hoe Gebruik Je Deze JSON naar JSON Schema Tool

1. Plak of typ je voorbeeld JSON in de editor hieronder. De tool accepteert elke geldige JSON, van eenvoudige objecten tot diep geneste structuren.
2. Klik op 'Genereer JSON Schema' om het geproduceerde JSON Schema te genereren en te bekijken.
3. Kopieer, bewerk of download het schema. Integreer het direct in je API-definities, validatielogica of documentatie.

Codevoorbeelden voor het genereren van schema's uit JSON

Bekijk hoe je JSON Schema genereert vanuit JSON in verschillende programmeertalen.

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.