Generator online JSON la JSON Schema

Cum funcționează generarea schemei în detaliu

Generarea unui JSON Schema dintr-un JSON exemplu depășește maparea simplă a câmpurilor pe tipuri. Acest instrument aplică mai mulți pași esențiali pentru corectitudine și completitudine:

1. Parsare: Instrumentul analizează JSON-ul conform ECMA-404, raportând erori detaliate pentru input greșit sau construcții ambigue.
2. Analiză structurală: Construiește o reprezentare în arbore a datelor dvs., clasificând fiecare proprietate și element conform tipurilor de bază JSON Schema (obiect, array, string, number, integer, boolean, null).
3. Parcurgere recursivă: Structurile complexe și imbricate – inclusiv array-uri de obiecte sau array-uri imbricate – sunt parcurse recursiv pentru a genera definiții de schemă imbricate.
4. Inferență și combinare tipuri: Pentru fiecare proprietate sau element din array se inferă tipurile. Dacă au tipuri mixte, 'type' este exprimat ca un array (tip union) conform specificației JSON Schema.
5. Detectarea câmpurilor obligatorii vs. opționale: Prin analizarea tuturor obiectelor la fiecare nivel, instrumentul distinge între chei prezente mereu (obligatorii) și cele uneori lipsă (opționale).
6. Constrângeri pe valori: Unde este posibil, instrumentul inferă enumerații (set de valori permise), valori min/max pentru numere, lungimi minime/maxime pentru stringuri și sugestii de format (de exemplu 'email', 'uri', 'date-time').
7. Gestionarea cazurilor speciale: Se acordă atenție specială array-urilor goale, valorilor null și structurilor rarefiate – asigurând scheme valide care reflectă variabilitatea reală.
8. Sinteza schemei: Schema finală este emisă ca document Draft-07 conform standardelor – gata de utilizare cu instrumente precum Ajv, OpenAPI sau biblioteci de generare cod.

De ce să generezi JSON Schema? Utilizări practice

• Validare automată: Folosiți schemele generate pentru a impune contracte de date și a valida payload-uri primite în API-urile, microserviciile sau CLI-urile dvs.
• Documentație API: Generați automat documentație și exploratoare interactive (Swagger, Postman) cu definiții precise ale datelor.
• Generare cod: Creați modele sau validatoare tip safe în TypeScript, Python, Java și alte limbaje folosind schema ca sursă unică de adevăr.
• Generare date test: Instrumente precum JSON Schema Faker sau Mockaroo folosesc scheme pentru a crea date mock realiste pentru testare QA și simulări de încărcare.
• Refactorizare & migrare: Validați structuri de date vechi sau în schimbare, asigurând compatibilitatea pe măsură ce backend-ul evoluează.

Funcționalități tehnice

• Compatibilitate Draft-07 pentru interoperabilitate maximă cu validatoare majore și platforme de design API.
• Analiză recursivă la orice adâncime – array-uri în array-uri, obiecte în array-uri și altele.
• Inferență precisă a tipurilor union (array 'type') pentru câmpurile sau elementele cu tipuri variate în exemple.
• Detecția automată a enumerațiilor, lungimilor, tiparelor, formatului, valorilor min/max și altor constrângeri comune.
• Suport explicit pentru valori null, array-uri/obiecte goale și înregistrări parțiale.
• Generarea schemei se realizează integral în browser. JSON-ul dvs. nu părăsește dispozitivul.

Exemplu tehnic: De la JSON exemplu la schema Draft-07

{
  "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"]
}

Cum se folosește acest instrument JSON la JSON Schema

1. Lipiți sau tastați JSON-ul exemplu în editorul de mai jos. Instrumentul acceptă orice JSON valid, de la obiecte simple la structuri profund imbricate.
2. Faceți clic pe „Generează schema JSON“ pentru a genera și vizualiza schema JSON obținută.
3. Copiați, editați sau descărcați schema. Integrați-o direct în definițiile API, logica de validare sau documentația dvs.

Exemple de Cod pentru Generarea Schemelor din JSON

Află cum să generezi schema JSON din JSON în diverse limbaje de programare.

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.