Online JSON sa JSON Schema Generator

Paano Gumagana ang Paggawa ng Schema Sa Likod ng Eksena

Ang paggawa ng JSON Schema mula sa sample na JSON ay higit pa sa simpleng pagma-map ng mga field sa mga uri. Ang tool na ito ay gumagamit ng ilang mahahalagang hakbang para sa katumpakan at kumpletong resulta:

1. Parsing: Tinitingnan ng tool ang iyong JSON ayon sa ECMA-404, nag-uulat ng detalyadong error para sa mga maling input o hindi malinaw na mga istruktura.
2. Pagsusuri ng Istruktura: Gumagawa ito ng puno ng representasyon ng iyong datos, inuri ang bawat property at elemento ayon sa pangunahing mga uri ng JSON Schema (object, array, string, number, integer, boolean, null).
3. Recursive na Paglalakad: Ang malalim at nested na mga istruktura—kabilang ang mga array ng mga object o nested na array—ay sinusuri nang recursive upang makabuo ng nested na mga depinisyon ng schema.
4. Inference at Pagsasama-sama ng Uri: Para sa bawat property o elemento ng array, tinutukoy ang uri. Kapag ang mga property o item ay may halong uri, ang 'type' ay inilalahad bilang array (union type) ayon sa spec ng JSON Schema.
5. Pagkilala sa Kinakailangan vs. Opsyonal: Sa pamamagitan ng pagsusuri ng lahat ng mga object sa bawat antas, tinutukoy ng tool ang mga susi na palaging naroroon (required) at minsang nawawala (optional).
6. Mga Limitasyon sa Halaga: Kung posible, tinutukoy ng tool ang enums (hanay ng pinapayagang mga halaga), min/max para sa mga numero, minLength/maxLength para sa mga string, at mga hint ng format (tulad ng 'email', 'uri', o 'date-time').
7. Paghawak ng Edge Cases: Binibigyang-pansin ang mga walang laman na array, null, at sparse na mga istruktura—nagtitiyak ng balidong schema na tumutugma sa totoong pagkakaiba-iba.
8. Pagsasama-sama ng Schema: Ang huling schema ay inilalabas bilang dokumentong sumusunod sa pamantayan ng Draft-07—handa para gamitin sa mga tool tulad ng Ajv, OpenAPI, o mga library para sa pagbuo ng code.

Bakit Gumawa ng JSON Schema? Praktikal na Paggamit

• Automated Validation: Gamitin ang mga gawaing schema upang ipatupad ang mga kontrata ng datos at beripikahin ang mga papasok na payload sa iyong API, microservices, o CLIs.
• Dokumentasyon ng API: Awtomatikong gumawa ng mga dokumento at interactive na mga explorer (Swagger, Postman) na may eksaktong depinisyon ng datos.
• Pagbuo ng Code: Lumikha ng type-safe na mga modelo o validator sa TypeScript, Python, Java, at iba pang mga lengguwahe gamit ang iyong schema bilang tanging pinagkukunan ng katotohanan.
• Paggawa ng Test Data: Ang mga tool tulad ng JSON Schema Faker o Mockaroo ay gumagamit ng mga schema upang makagawa ng makatuwirang mock data para sa QA at load testing.
• Refactoring at Migrasyon: Beripikahin ang mga legacy o nagbabagong istruktura ng datos, tinutiyak ang pagiging compatible habang umuunlad ang iyong backend.

Mga Teknikal na Katangian

• Pagsuporta sa Draft-07 para sa pinakamataas na interoperability sa mga pangunahing validator at mga platform ng disenyo ng API.
• Recursive na pagsusuri ng anumang lalim ng pag-nest—arrays sa loob ng arrays, mga object sa loob ng arrays, atbp.
• Tumpak na inference ng union type ('type' array) para sa mga field o item na nag-iiba-iba sa mga sample.
• Awtomatikong pagtuklas ng mga enums, haba, pattern, format, min/max, at iba pang karaniwang limitasyon.
• Tahasang pagsuporta sa nulls, walang laman na mga array/object, at bahagyang mga rekord.
• Ang paggawa ng schema ay nagaganap nang ganap sa browser. Ang iyong input JSON ay hindi umaalis sa iyong device.

Teknikal na Halimbawa: Mula sa Sample JSON hanggang Draft-07 Schema

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

Paano Gamitin ang JSON sa JSON Schema Tool na Ito

1. I-paste o i-type ang iyong halimbawa ng JSON sa editor sa ibaba. Tumanggap ang tool ng anumang balidong JSON, mula sa simpleng mga object hanggang sa malalalim na nested na istruktura.
2. I-click ang 'Gumawa ng JSON Schema' upang bumuo at makita ang nalikhang JSON Schema.
3. Kopyahin, i-edit, o i-download ang schema. Direktang isama ito sa iyong mga definisyon ng API, lohika sa beripikasyon, o dokumentasyon.

Mga Halimbawang Kodigo para sa Pagbuo ng Schema mula sa JSON

Tingnan kung paano gumawa ng JSON Schema mula sa JSON gamit ang iba't ibang programming language.

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.