เครื่องมือสร้าง JSON Schema ออนไลน์

การทำงานเบื้องหลังของการสร้างสคีมา

การสร้าง JSON Schema จาก JSON ตัวอย่างไม่ใช่แค่จับคู่ฟิลด์กับชนิดข้อมูลเท่านั้น แต่เครื่องมือนี้ใช้ขั้นตอนสำคัญหลายอย่างเพื่อความถูกต้องและสมบูรณ์แบบ:

1. การแยกวิเคราะห์: เครื่องมือแยกวิเคราะห์ JSON ของคุณตามมาตรฐาน ECMA-404 พร้อมรายงานข้อผิดพลาดอย่างละเอียดสำหรับข้อมูลที่ไม่ถูกต้องหรือสร้างความคลุมเครือ
2. การวิเคราะห์โครงสร้าง: สร้างแผนผังต้นไม้ของข้อมูล จัดประเภทคุณสมบัติและองค์ประกอบแต่ละรายการตามชนิดหลักใน JSON Schema (object, array, string, number, integer, boolean, null)
3. การสำรวจแบบเรียกซ้ำ: โครงสร้างที่ลึกและซ้อนกัน — รวมถึงอาร์เรย์ของอ็อบเจ็กต์หรืออาร์เรย์ซ้อน—ถูกสำรวจแบบเรียกซ้ำเพื่อสร้างคำนิยามสคีมาแบบซ้อน
4. การสังเคราะห์และรวมชนิดข้อมูล: สำหรับแต่ละคุณสมบัติหรือองค์ประกอบในอาร์เรย์ จะสังเคราะห์ชนิดข้อมูล หากมีชนิดข้อมูลผสม 'type' จะถูกระบุเป็นอาร์เรย์ (union type) ตามข้อกำหนดของ JSON Schema
5. การตรวจจับความจำเป็น: โดยการวิเคราะห์ทั้งหมดของอ็อบเจ็กต์ในแต่ละระดับ เครื่องมือแยกแยะระหว่างคีย์ที่ต้องมีตลอดเวลา (required) และคีย์ที่บางครั้งอาจขาดหายไป (optional)
6. ข้อจำกัดของค่า: เมื่อเป็นไปได้ เครื่องมือจะสังเคราะห์ค่า enums (ชุดค่าที่อนุญาต), min/max สำหรับตัวเลข, minLength/maxLength สำหรับสตริง และรูปแบบ เช่น 'email', 'uri' หรือ 'date-time'
7. จัดการกรณีพิเศษ: ให้ความสำคัญกับอาร์เรย์ว่าง, ค่าที่เป็น null และโครงสร้างแบบกระจัดกระจาย เพื่อให้ได้สคีมาที่ถูกต้องและสะท้อนความหลากหลายในโลกจริง
8. สังเคราะห์สคีมา: สคีมาสุดท้ายจะถูกส่งออกในรูปแบบเอกสาร Draft-07 ที่สอดคล้องกับมาตรฐาน พร้อมใช้งานกับเครื่องมืออย่าง Ajv, OpenAPI หรือไลบรารีสร้างโค้ด

ทำไมต้องสร้าง JSON Schema? การใช้งานที่เป็นประโยชน์

• การตรวจสอบอัตโนมัติ: ใช้สคีมาที่สร้างขึ้นเพื่อบังคับใช้ข้อตกลงข้อมูลและตรวจสอบ payload ที่เข้ามาใน API, ไมโครเซอร์วิส หรือ CLI ของคุณ
• เอกสาร API: สร้างเอกสารและตัวสำรวจแบบอินเทอร์แอคทีฟ (Swagger, Postman) อัตโนมัติด้วยคำจำกัดความข้อมูลที่แม่นยำ
• การสร้างโค้ด: สร้างโมเดลหรือผู้ตรวจสอบแบบปลอดภัยจากชนิดใน TypeScript, Python, Java และภาษาอื่น ๆ โดยใช้สคีมาเป็นแหล่งข้อมูลเดียว
• สร้างข้อมูลทดสอบ: เครื่องมืออย่าง JSON Schema Faker หรือ Mockaroo ใช้สคีมาในการสร้างข้อมูลจำลองที่สมจริงเพื่อทดสอบ QA และโหลดเทสติ้ง
• รีแฟกเตอร์และย้ายข้อมูล: ตรวจสอบโครงสร้างข้อมูลเก่าหรือที่เปลี่ยนแปลงเพื่อให้มั่นใจว่าความเข้ากันได้ในขณะที่ระบบ backend พัฒนาต่อไป

คุณสมบัติทางเทคนิค

• รองรับมาตรฐาน Draft-07 เพื่อความเข้ากันได้สูงสุดกับเครื่องมือตรวจสอบและแพลตฟอร์มออกแบบ API ชั้นนำ
• วิเคราะห์โครงสร้างซ้อนกันได้ทุกระดับ — อาร์เรย์ในอาร์เรย์, อ็อบเจ็กต์ในอาร์เรย์ และอื่นๆ
• สังเคราะห์ union type ('type' เป็นอาร์เรย์) อย่างแม่นยำสำหรับฟิลด์หรือรายการที่แตกต่างกันในตัวอย่าง
• ตรวจจับ enums, ความยาว, รูปแบบ, รูปแบบเฉพาะ, min/max และข้อจำกัดทั่วไปอื่นๆ อัตโนมัติ
• รองรับอย่างชัดเจนสำหรับค่า null, อาร์เรย์หรืออ็อบเจ็กต์ว่าง และระเบียนบางส่วน
• การสร้างสคีมาทำงานทั้งหมดในเบราว์เซอร์ ข้อมูล JSON ของคุณไม่ถูกส่งออกไปที่ใด

ตัวอย่างทางเทคนิค: จาก JSON ตัวอย่างสู่สคีมา 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"]
}

วิธีใช้เครื่องมือ JSON เป็น JSON Schema นี้

1. วางหรือพิมพ์ JSON ตัวอย่างของคุณในตัวแก้ไขด้านล่าง เครื่องมือรองรับ JSON ที่ถูกต้องทุกประเภท ตั้งแต่โครงสร้างง่ายๆ ถึงซับซ้อนซ้อนกันลึก
2. คลิก 'สร้าง JSON Schema' เพื่อสร้างและดู JSON Schema ที่ได้
3. คัดลอก แก้ไข หรือดาวน์โหลดสคีมา นำไปใช้กับนิยาม API, ตรรกะการตรวจสอบ หรือเอกสารของคุณโดยตรง

ตัวอย่างโค้ดสำหรับการสร้างสคีมาจาก JSON

ดูวิธีสร้าง JSON Schema จาก JSON ในหลายภาษาโปรแกรมที่หลากหลาย

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.