Penjana Dalam Talian JSON ke Skema JSON

Bagaimana Penjanaan Skema Berfungsi di Balik Tabir

Menjana Skema JSON daripada contoh JSON melibatkan lebih daripada hanya memetakan medan ke jenis. Alat ini menggunakan beberapa langkah penting untuk ketepatan dan kelengkapan:

1. Pemeriksaan: Alat ini memeriksa JSON anda menurut ECMA-404, melaporkan ralat terperinci bagi input yang tidak sah atau konstruksi yang samar.
2. Analisis Struktur: Ia membina representasi pokok bagi data anda, mengklasifikasikan setiap sifat dan elemen mengikut jenis teras Skema JSON (objek, tatasusunan, rentetan, nombor, integer, boolean, null).
3. Penjelajahan Rekursif: Struktur yang mendalam dan bertingkat—termasuk tatasusunan objek atau tatasusunan bertingkat—dijelajah secara rekursif untuk menjana definisi skema bertingkat.
4. Inferens dan Penggabungan Jenis: Untuk setiap sifat atau elemen tatasusunan, jenis ditentukan. Bila sifat atau item mempunyai jenis bercampur, 'type' dinyatakan sebagai tatasusunan (jenis kesatuan) menurut spesifikasi Skema JSON.
5. Pengesanan Kunci Wajib dan Pilihan: Dengan menganalisis semua objek pada setiap tahap, alat membezakan antara kunci yang sentiasa hadir (wajib) dan kadang-kadang tiada (pilihan).
6. Kekangan Nilai: Bila boleh, alat infer enum (set nilai dibenarkan), min/maks untuk nombor, minLength/maxLength untuk rentetan, dan petunjuk format (seperti 'email', 'uri', atau 'date-time').
7. Pengendalian Kes Tepi: Perhatian khusus diberikan kepada tatasusunan kosong, null, dan struktur jarang—memastikan skema sah yang sesuai dengan variabiliti dunia sebenar.
8. Sintesis Skema: Skema akhir diterbitkan sebagai dokumen Draf-07 yang mematuhi piawaian—sedia untuk digunakan dengan alat seperti Ajv, OpenAPI, atau pustaka penjanaan kod.

Mengapa Menjana Skema JSON? Kegunaan Praktikal

• Pengesahan Automatik: Gunakan skema yang dijana untuk menguatkuasakan kontrak data dan mengesahkan muatan masuk dalam API, mikroservis, atau CLI anda.
• Dokumentasi API: Jana dokumentasi dan penjelajah interaktif (Swagger, Postman) secara automatik dengan definisi data tepat.
• Penjanaan Kod: Cipta model atau pengesah yang selamat jenis dalam TypeScript, Python, Java, dan bahasa lain menggunakan skema anda sebagai sumber kebenaran tunggal.
• Penjanaan Data Ujian: Alat seperti JSON Schema Faker atau Mockaroo menggunakan skema untuk mensintesis data contoh realistik bagi ujian QA dan beban.
• Pengubahsuaian & Migrasi: Sahkan struktur data lama atau berubah, memastikan keserasian semasa backend anda berkembang.

Ciri-ciri Teknikal

• Sokongan Draf-07 untuk kesalingoperasian maksimum dengan pengesah utama dan platform reka bentuk API.
• Analisis rekursif kedalaman tertanam apa pun—tatasusunan dalam tatasusunan, objek dalam tatasusunan, dan lain-lain.
• Inferens tepat jenis kesatuan ('type' tatasusunan) untuk medan atau item yang berubah antara contoh.
• Pengesanan otomatik enum, panjang, pola, format, min/maks, dan kekangan biasa lain.
• Sokongan eksplisit untuk null, tatasusunan/objek kosong, dan rekod sebahagian.
• Penjanaan skema dijalankan sepenuhnya dalam pelayar. JSON input anda tidak pernah meninggalkan peranti anda.

Contoh Teknikal: Dari JSON Contoh ke Skema Draf-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": "objek",
  "properties": {
    "transaction": {
      "type": "objek",
      "properties": {
        "id": { "type": "rentetan" },
        "amount": { "type": "nombor" },
        "currency": { "type": "rentetan", "minLength": 3, "maxLength": 3 },
        "status": { "type": "rentetan", "enum": ["completed"] },
        "meta": {
          "type": "objek",
          "properties": {
            "ip": { "type": "rentetan", "format": "ipv4" },
            "tags": {
              "type": "tatasusunan",
              "items": { "type": ["rentetan", "null"] }
            }
          },
          "required": ["ip", "tags"]
        }
      },
      "required": ["id", "amount", "currency", "status", "meta"]
    },
    "refunded": { "type": "boolean" },
    "notes": { "type": ["null"] }
  },
  "required": ["transaction", "refunded", "notes"]
}

Cara Menggunakan Alat JSON ke Skema JSON Ini

1. Tampal atau taip contoh JSON anda ke dalam editor di bawah. Alat ini menerima sebarang JSON sah, daripada objek ringkas hingga struktur bertingkat dalam.
2. Klik 'Jana Skema JSON' untuk menjana dan melihat Skema JSON yang dihasilkan.
3. Salin, sunting, atau muat turun skema. Integrasikan terus ke dalam definisi API, logik pengesahan, atau dokumentasi anda.

Contoh Kod untuk Penjanaan Skema daripada JSON

Lihat cara menjana Skema JSON daripada JSON dalam pelbagai bahasa pengaturcaraan.

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.