Tiešsaistes JSON uz JSON shēmas ģenerators

Kā darbojas shēmas ģenerēšana aizkulisēs

JSON shēmas ģenerēšana no JSON piemēra ietver vairāk nekā vienkāršu lauku sasaisti ar tipiem. Šis rīks izmanto vairākus svarīgus soļus, lai nodrošinātu pareizību un pilnīgumu:

1. Parsēšana: Rīks analizē jūsu JSON atbilstoši ECMA-404 standartam, ziņojot par sīkiem kļūdu aprakstiem par nederīgu ievadi vai neskaidriem elementiem.
2. Strukturālā analīze: Izveido datu koka attēlojumu, klasificējot katru īpašību un elementu pēc JSON shēmas pamattipiem (objekts, masīvs, virkne, skaitlis, veselais skaitlis, loģiskais, null).
3. Rekursīva apmeklēšana: Dziļas un sarakstītas struktūras — tostarp masīvi ar objektiem vai sarakstīti masīvi — tiek rekursīvi apstrādātas, lai ģenerētu ligzdotas shēmas definīcijas.
4. Tipu atvasināšana un apvienošana: Katram īpašumam vai masīva elementam tiek noteikti tipi. Ja elementi vai īpašības satur dažādus tipus, 'type' norāda kā masīvu (savienojuma tips) pēc JSON shēmas specifikācijas.
5. Obligāto un izvēles noteikšana: Analizējot visus objektus katrā līmenī, rīks atšķir vienmēr esošos (obligātos) un reizēm trūkstošos (izvēles) atslēgas.
6. Vērtību ierobežojumi: Kur iespējams, rīks atvasina enumerācijas (atļauto vērtību kopu), min/max skaitļiem, minLength/maxLength virknei un formāta norādes (piemēram, 'email', 'uri' vai 'date-time').
7. Īpašo gadījumu apstrāde: Pievērš īpašu uzmanību tukšiem masīviem, null vērtībām un neregulārām struktūrām — nodrošinot derīgas shēmas, kas atbilst reālām datu variācijām.
8. Shēmas sintēze: Gala shēma tiek izlaista kā standartiem atbilstošs Draft-07 dokuments — gatavs lietošanai ar tādiem rīkiem kā Ajv, OpenAPI vai koda ģenerēšanas bibliotēkām.

Kāpēc ģenerēt JSON shēmu? Praktiskās pielietošanas iespējas

• Automātiska validācija: Izmantojiet ģenerētās shēmas, lai nodrošinātu datu līgumu izpildi un pārbaudītu ienākošos datus jūsu API, mikropakalpojumos vai komandrindas rīkos.
• API dokumentācija: Automātiski ģenerējiet dokumentāciju un interaktīvos pārlūkus (Swagger, Postman) ar precīzām datu definīcijām.
• Koda ģenerēšana: Izveidojiet tipdrošus modeļus vai validētājus TypeScript, Python, Java un citās valodās, izmantojot shēmu kā vienīgo patiesības avotu.
• Testa datu ģenerēšana: Rīki kā JSON Schema Faker vai Mockaroo izmanto shēmas, lai sintezētu reālistiskus testēšanas datus kvalitātes nodrošināšanai un slodzes testēšanai.
• Pārbūve un migrācija: Validējiet vecās vai mainīgās datu struktūras, nodrošinot saderību attīstoties jūsu aizmugures sistēmai.

Tehniskās funkcijas

• Draft-07 saderība maksimālai savietojamībai ar galvenajiem validatoriem un API izstrādes platformām.
• Rekursīva analīze jebkuram ligzdošanas dziļumam — masīvi masīvos, objekti masīvos un citi.
• Precīza savienojuma tipu ('type' masīva) noteikšana laukiem vai elementiem, kas mainās starp paraugiem.
• Automātiska enumerāciju, garuma, rakstura, formāta, min/max un citu ierobežojumu atpazīšana.
• Eksplīcīta null vērtību, tukšu masīvu/objektu un daļēju ierakstu atbalsts.
• Shēmas ģenerēšana notiek pilnībā pārlūkprogrammā. Jūsu ievades JSON nekad neatstāj ierīci.

Tehnisks piemērs: no JSON parauga līdz Draft-07 shēmai

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

Kā lietot šo JSON uz JSON shēmas rīku

1. Ielīmējiet vai ierakstiet savu JSON paraugu redaktorā zemāk. Rīks pieņem jebkuru derīgu JSON, no vienkāršiem objektiem līdz dziļi ligzdotām struktūrām.
2. Nospiediet 'Ģenerēt JSON shēmu', lai izveidotu un aplūkotu rezultātā iegūto JSON shēmu.
3. Kopējiet, rediģējiet vai lejupielādējiet shēmu. Integrējiet to tieši savos API aprakstos, validācijas kodā vai dokumentācijā.

Kodu piemēri JSON pārveidei par shēmu

Skatiet, kā ģenerēt JSON shēmu no JSON dažādās programmēšanas valodās.

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.