Trình tạo JSON Schema trực tuyến

Cách hoạt động của việc tạo Schema

Việc tạo JSON Schema từ mẫu JSON không chỉ là ánh xạ trường sang kiểu. Công cụ này thực hiện nhiều bước chính để đảm bảo đúng và đầy đủ:

1. Phân tích cú pháp: Công cụ phân tích cú pháp JSON của bạn theo chuẩn ECMA-404, báo lỗi chi tiết khi phát hiện dữ liệu sai hoặc cấu trúc không rõ ràng.
2. Phân tích cấu trúc: Xây dựng cây biểu diễn dữ liệu, phân loại mỗi thuộc tính và phần tử theo các kiểu lõi của JSON Schema (object, array, string, number, integer, boolean, null).
3. Duyệt đệ quy: Duyệt sâu qua các cấu trúc lồng nhau—bao gồm mảng đối tượng hoặc mảng lồng nhau—để tạo định nghĩa schema lặp.
4. Suy luận và kết hợp kiểu: Với mỗi thuộc tính hoặc phần tử mảng, suy luận kiểu dữ liệu. Nếu thuộc tính hoặc mục có nhiều kiểu hỗn hợp, 'type' sẽ là mảng (kiểu hợp) theo chuẩn JSON Schema.
5. Phát hiện cần thiết và tùy chọn: Qua việc phân tích tất cả đối tượng ở mỗi cấp, công cụ xác định khóa luôn có (bắt buộc) và khóa có thể thiếu (tùy chọn).
6. Ràng buộc giá trị: Khi có thể, công cụ suy luận enum (tập giá trị cho phép), min/max cho số, minLength/maxLength cho chuỗi, và định dạng gợi ý (như 'email', 'uri', hoặc 'date-time').
7. Xử lý trường hợp đặc biệt: Quan tâm đặc biệt đến mảng rỗng, giá trị null, và cấu trúc thưa thớt—đảm bảo schema hợp lệ mô phỏng biến thể thực tế.
8. Tổng hợp schema: Schema cuối cùng được xuất ra là tài liệu Draft-07 tuân thủ chuẩn—sẵn sàng sử dụng với các công cụ như Ajv, OpenAPI hoặc thư viện tạo mã.

Tại sao tạo JSON Schema? Các ứng dụng thực tiễn

• Xác thực tự động: Dùng schema tạo để kiểm soát hợp đồng dữ liệu và xác thực payload đầu vào trong API, microservices hoặc CLI của bạn.
• Tài liệu API: Tự động tạo tài liệu và trình khám phá tương tác (Swagger, Postman) với định nghĩa dữ liệu chính xác.
• Tạo mã: Tạo mô hình hoặc trình xác thực an toàn kiểu trong TypeScript, Python, Java và các ngôn ngữ khác dựa trên schema làm nguồn duy nhất.
• Tạo dữ liệu thử nghiệm: Công cụ như JSON Schema Faker hoặc Mockaroo dùng schema để tạo dữ liệu giả thực tế cho kiểm thử chất lượng và tải.
• Tái cấu trúc & di cư: Xác thực cấu trúc dữ liệu cũ hoặc thay đổi, đảm bảo tương thích khi backend phát triển.

Tính năng kỹ thuật

• Tương thích Draft-07 cho khả năng tương tác tối đa với các trình xác thực và nền tảng thiết kế API phổ biến.
• Phân tích đệ quy sâu bất kỳ cấp độ lồng nhau—mảng trong mảng, đối tượng trong mảng, v.v.
• Suy luận chính xác kiểu hợp ('type' dưới dạng mảng) cho trường hoặc phần tử thay đổi giữa các mẫu.
• Phát hiện tự động enum, độ dài, mẫu, định dạng, giá trị min/max và các ràng buộc thông dụng khác.
• Hỗ trợ rõ ràng cho nulls, mảng/đối tượng rỗng và bản ghi không đầy đủ.
• Tạo schema hoàn toàn chạy trong trình duyệt. JSON bạn nhập không bao giờ rời thiết bị của bạn.

Ví dụ kỹ thuật: Từ JSON mẫu đến 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"]
}

Cách sử dụng công cụ chuyển JSON thành JSON Schema này

1. Dán hoặc nhập JSON mẫu của bạn vào trình soạn thảo bên dưới. Công cụ chấp nhận mọi JSON hợp lệ, từ đối tượng đơn giản đến cấu trúc lồng sâu.
2. Nhấn 'Tạo JSON Schema' để tạo và xem Schema JSON được tạo ra.
3. Sao chép, chỉnh sửa hoặc tải xuống schema. Tích hợp trực tiếp vào định nghĩa API, logic xác thực hoặc tài liệu của bạn.

Ví dụ Mã cho Chuyển Đổi JSON sang Schema

Tìm hiểu cách tạo JSON Schema từ JSON bằng nhiều ngôn ngữ lập trình khác nhau.

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.