ਆਨਲਾਈਨ JSON ਤੋਂ JSON ਸਕੀਮਾ ਜਨਰੇਟਰ

ਸਕੀਮਾ ਬਣਾਉਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ

ਸਮਪਲ JSON ਤੋਂ JSON ਸਕੀਮਾ ਬਣਾਉਣਾ ਕਰੇਤਰਾਂ ਨੂੰ ਕਿਸਮਾਂ ਨਾਲ ਜੋੜਨ ਤੋਂ ਵਧ ਕੇ ਹੁੰਦਾ ਹੈ। ਇਹ ਟੂਲ ਸਹੀ ਅਤੇ ਪੂਰਨ ਪਰਿਣਾਮ ਲਈ ਕੁਝ ਮੁੱਖ ਕਦਮਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ:

1. ਪਾਰਸਿੰਗ: ਟੂਲ ਤੁਹਾਡੇ JSON ਨੂੰ ECMA-404 ਅਨੁਸਾਰ ਪਾਰਸ ਕਰਦਾ ਹੈ ਅਤੇ ਖਰਾਬ ਇਨਪੁੱਟ ਜਾਂ ਸਪੱਸ਼ਟ ਨਾ ਹੋਣ ਵਾਲੇ ਬਣਾਵਟਾਂ ਲਈ ਵਿਸਥਾਰ ਨਾਲ ਗਲਤੀ ਦਰਸਾਉਂਦਾ ਹੈ।
2. ਸੰਰਚਨਾਤਮਕ ਵਿਸ਼ਲੇਸ਼ਣ: ਇਹ ਤੁਹਾਡੇ ਡੇਟਾ ਦੀ ਇੱਕ ਟਰੀ ਪ੍ਰਤੀਨਿਧੀਤਾ ਬਣਾਉਂਦਾ ਹੈ, ਹਰ ਗੁਣ ਅਤੇ ਤੱਤ ਨੂੰ JSON ਸਕੀਮਾ ਦੇ ਮੁੱਖ ਕਿਸਮਾਂ (ਵਸਤੂ, ਸੂਚੀ, ਸਤਰ, ਨੰਬਰ, ਪੂਰਾ ਨੰਬਰ, ਬੂਲੀਅਨ, ਨੱਲ) ਦੇ ਨਾਲ ਵਰਗੀਕ੍ਰਿਤ ਕਰਦਾ ਹੈ।
3. ਆਵਰਤੀ ਯਾਤਰਾ: ਡੂੰਘੇ ਅਤੇ ਨੈਸਟਿਡ ਬਣਾਵਟਾਂ—ਜਿਵੇਂ ਕਿ ਵਸਤੂਆਂ ਵਾਲੀਆਂ ਸੂਚੀਆਂ ਜਾਂ ਨੈਸਟਿਡ ਅਰੇ— ਨੂੰ ਮੁੜ-ਮੁੜ ਪਾਰ ਕਰਕੇ ਨੈਸਟਿਡ ਸਕੀਮਾ ਪਰਿਭਾਸ਼ਾਵਾਂ ਬਣਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ।
4. ਕਿਸਮ ਦੀ ਪਛਾਣ ਅਤੇ ਮਿਲਾਪ: ਹਰ ਗੁਣ ਜਾਂ ਅਰੇ ਆਈਟਮ ਲਈ ਕਿਸਮਾਂ ਦੀ ਪਛਾਣ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਜਿੱਥੇ ਗੁਣਾਂ ਜਾਂ ਆਈਟਮਾਂ ਵਿੱਚ ਮਿਲੇ-ਜੁਲੇ ਕਿਸਮਾਂ ਹੁੰਦੀਆਂ ਹਨ, 'type' ਨੂੰ ਸੂਚੀ ਵਜੋਂ (ਯੂਨੀਅਨ ਕਿਸਮ) ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ JSON ਸਕੀਮਾ ਵਿਸ਼ੇਸ਼ਤਾ ਅਨੁਸਾਰ।
5. ਲਾਜ਼ਮੀ ਅਤੇ ਵਿਕਲਪੀ ਚਾਬੀਆਂ ਦੀ ਪਹਿਚਾਣ: ਹਰ ਪੱਧਰ ਤੇ ਸਾਰੇ ਵਸਤੂਆਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਕੇ, ਟੂਲ ਹਮੇਸ਼ਾ ਮੌਜੂਦ (ਲਾਜ਼ਮੀ) ਅਤੇ ਕਦੇ ਕਦੇ ਗੈਰ-ਮੌਜੂਦ (ਵਿਕਲਪੀ) ਚਾਬੀਆਂ ਨੂੰ ਵੱਖ ਕਰਦਾ ਹੈ।
6. ਮूलਯ ਪਾਬੰਦੀਆਂ: ਜਿੱਥੇ ਸੰਭਵ ਹੋਵੇ, ਟੂਲ ਇਨਮ (ਮਾਨੀਤ ਕੀਤੇ ਮੁੱਲਾਂ ਦਾ ਸੈੱਟ), ਗਿਣਤੀ ਲਈ ਮਿਨ/ਮੈਕਸ, ਸਤਰਾਂ ਲਈ ਮਿਨ ਲੰਬਾਈ/ਮੈਕਸ ਲੰਬਾਈ, ਅਤੇ ਫਾਰਮੈਟ ਸੁਝਾਅ (ਜਿਵੇਂ 'ਈਮੇਲ', 'uri', ਜਾਂ 'ਡੇਟ-ਟਾਈਮ') ਦੀ ਪਛਾਣ ਕਰਦਾ ਹੈ।
7. ਖਾਸ ਮਾਮਲਿਆਂ ਦਾ ਪ੍ਰਬੰਧ: ਖਾਲੀ ਅਰੇਜ਼, ਨੱਲ ਅਤੇ ਛਿੜਕੇ ਹੋਏ ਬਣਾਵਟਾਂ ਨੂੰ ਵਿਸ਼ੇਸ਼ ਧਿਆਨ ਨਾਲ ਵਿਭਿੰਨਤਾ ਨਾਲ ਮਿਲਦੀਆਂ ਵੈਧ ਸਕੀਮਾਂ ਬਣਾਉਣ ਲਈ ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ।
8. ਸਕੀਮਾ ਸੰਸ਼ਲੇਸ਼ਣ: ਆਖਰੀ ਸਕੀਮਾ ਇੱਕ ਮਿਆਰੀ ਬਨਾਵਟੀ ਡ੍ਰਾਫਟ-07 ਦਸਤਾਵੇਜ਼ ਵਜੋਂ ਜਾਰੀ ਕੀਤਾ ਜਾਂਦਾ ਹੈ—ਜੋ Ajv, OpenAPI ਜਾਂ ਕੋਡ ਜਨਰੇਸ਼ਨ ਲਾਇਬ੍ਰੇਰੀਆਂ ਵਰਗੇ ਸੰਦਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਤਿਆਰ ਹੈ।

JSON ਸਕੀਮਾ ਬਣਾਉਣ ਦੇ ਕਾਰਣ ਅਤੇ ਵਿਆਹਾਰਕ ਵਰਤਾਰੇ

• ਸਵੈਚਾਲਿਤ ਵੈਧਤਾ: ਬਣਾਏ ਗਏ ਸਕੀਮਿਆਂ ਨੂੰ ਆਪਣੇ APIs, ਮਾਈਕਰੋਸਰਵਿਸਜ਼ ਜਾਂ CLI ਵਿੱਚ ਡਾਟਾ ਕਰਾਰ ਲਾਗੂ ਕਰਨ ਅਤੇ ਆ ਰਹੇ ਪੇਲੋਡਾਂ ਦੀ ਪੜਤਾਲ ਲਈ ਵਰਤੋਂ।
• API ਦਸਤਾਵੇਜ਼ੀਕਰਨ: ਸਹੀ ਡੇਟਾ ਪਰਿਭਾਸ਼ਾਵਾਂ ਨਾਲ ਦਸਤਾਵੇਜ਼ ਅਤੇ ਇੰਟਰਐਕਟਿਵ ਐਕਸਪਲੋਰਰ (Swagger, Postman) ਆਟੋ-ਪੈਦਾ ਕਰੋ।
• ਕੋਡ ਜਨਰੇਸ਼ਨ: ਆਪਣੇ ਸਕੀਮਾ ਨੂੰ ਏਕ ਸੱਚਾਈ ਦੇ ਸਰੋਤ ਵਜੋਂ ਵਰਤ ਕੇ ਟਾਈਪ-ਸੁਰੱਖਿਅਤ ਮਾਡਲ ਜਾਂ ਵੈਧਕ ਟਾਈਪਸਕ੍ਰਿਪਟ, ਪਾਇਥਨ, ਜਾਵਾ ਅਤੇ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਬਣਾਓ।
• ਟੈਸਟ ਡੇਟਾ ਤਿਆਰ ਕਰਨਾ: JSON ਸਕੀਮਾ ਫੇਕਰ ਜਾਂ ਮੋਕਾਰੂ ਵਰਗੇ ਸੰਦ QA ਅਤੇ ਲੋਡ ਟੈਸਟਿੰਗ ਲਈ ਹਕੀਕਤ ਦੀ ਤਰ੍ਹਾਂ ਮੌਕ ਡੇਟਾ ਪੈਦਾ ਕਰਨ ਲਈ ਸਕੀਮਿਆਂ ਦਾ ਉਪਯੋਗ ਕਰਦੇ ਹਨ।
• ਪੁਨਰਰਚਨਾ ਅਤੇ ਮਾਈਗਰੇਸ਼ਨ: ਵਿਰਾਸਤੀ ਜਾਂ ਬਦਲ ਰਹੀਆਂ ਡੇਟਾ ਸੰਰਚਨਾਵਾਂ ਦੀ ਵੈਧਤਾ ਕਰਕੇ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਜਦੋਂ ਤੁਹਾਡਾ ਬੈਕਐਂਡ ਵਿਕਸਤ ਹੁੰਦਾ ਹੈ ਤਾਂ ਉਹ ਅਨੁਕੂਲ ਹਨ।

ਤਕਨੀਕੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ

• ਡ੍ਰਾਫਟ-07 ਦੀ ਅਨੁਕੂਲਤਾ ਵੱਡੇ ਵੈਧਕਾਰਾਂ ਅਤੇ API ਡਿਜ਼ਾਈਨ ਪਲੇਟਫਾਰਮਾਂ ਨਾਲ ਵੱਧ ਤੋਂ ਵੱਧ ਇੰਟਰਓਪਰੇਬਿਲਿਟੀ ਲਈ।
• ਕਿਸੇ ਵੀ ਗਹਿਲਾਈ ਦੀ ਨੈਸਟਿੰਗ ਦਾ ਆਵਰਤੀ ਵਿਸ਼ਲੇਸ਼ਣ—ਅਰੇਜ਼ ਦੇ ਅੰਦਰ ਅਰੇਜ਼, ਅਰੇਜ਼ ਦੇ ਅੰਦਰ ਵਸਤੂਆਂ ਅਤੇ ਹੋਰ।
• ਉਦਾਹਰਨਾਂ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਵਾਲੇ ਫੀਲਡਾਂ ਜਾਂ ਆਈਟਮਾਂ ਲਈ ਸਹੀ ਯੂਨੀਅਨ ਕਿਸਮ ('type' ਸੂਚੀ) ਦੀ ਪਛਾਣ।
• ਇਨਮ, ਲੰਬਾਈ, ਪੈਟਰਨ, ਫਾਰਮੈਟ, ਮਿਨ/ਮੈਕਸ ਅਤੇ ਹੋਰ ਸਾਂਝੀਆਂ ਪਾਬੰਦੀਆਂ ਦੀ ਸਵੈਚਾਲਿਤ ਪਛਾਣ।
• ਨੁੱਲ, ਖਾਲੀ ਅਰੇਜ਼/ਵਸਤੂਆਂ ਅਤੇ ਆਧੂਰੀ ਦਰਜਾਂ ਲਈ ਵਿਸ਼ੇਸ਼ ਸਹਾਇਤਾ।
• ਸਕੀਮਾ ਬਣਾਉਣ ਦੀ ਸਮੂਹ ਪ੍ਰਕਿਰਿਆ ਪੂਰੀ ਤਰ੍ਹਾਂ ਬ੍ਰਾਉਜ਼ਰ ਵਿੱਚ ਚੱਲਦੀ ਹੈ। ਤੁਹਾਡਾ ਇਨਪੁੱਟ JSON ਕਦੇ ਵੀ ਤੁਹਾਡੇ ਡਿਵਾਈਸ ਤੋਂ ਬਾਹਰ ਨਹੀਂ ਜਾਂਦਾ।

ਤਕਨੀਕੀ ਉਦਾਹਰਣ: ਸੈਂਪਲ JSON ਤੋਂ ਡ੍ਰਾਫਟ-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 ਸਕੀਮਾ ਸੰਦ ਨੂੰ ਕਿਵੇਂ ਵਰਤਣਾ ਹੈ

1. ਹੇਠਾਂ ਏਡਿਟਰ ਵਿੱਚ ਆਪਣਾ ਮਿਸਾਲ JSON ਪੇਸਟ ਜਾਂ ਟਾਈਪ ਕਰੋ। ਇਹ ਟੂਲ ਕਿਸੇ ਵੀ ਵੈਧ JSON ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ, ਸਾਧਾਰਣ ਵਸਤੂਆਂ ਤੋਂ ਲੈ ਕੇ ਡੂੰਘੀ ਨੈਸਟਿਡ ਸੰਰਚਨਾਵਾਂ ਤੱਕ।
2. 'Generate JSON Schema' ਬਟਨ 'ਤੇ ਕਲਿੱਕ ਕਰੋ ਤਾਂ ਜੋ ਬਣਾਇਆ ਗਿਆ JSON ਸਕੀਮਾ ਵੇਖਿਆ ਜਾ ਸਕੇ।
3. ਸਕੀਮਾ ਨੂੰ ਕਾਪੀ ਕਰੋ, ਸੰਪਾਦਿਤ ਕਰੋ ਜਾਂ ਡਾਊਨਲੋਡ ਕਰੋ। ਇਸਨੂੰ ਆਪਣੀਆਂ API ਪਰਿਭਾਸ਼ਾਵਾਂ, ਵੈਧਤਾ ਲੌਜਿਕ ਜਾਂ ਦਸਤਾਵੇਜ਼ੀਕਰਨ ਵਿੱਚ ਸਿੱਧਾ ਸ਼ਾਮਲ ਕਰੋ।

JSON ਤੋਂ ਸਕੀਮਾ ਬਣਾਉਣ ਲਈ ਕੋਡ ਉਦਾਹਰਨਾਂ

ਵੇਖੋ ਕਿ ਕਿਵੇਂ ਵੱਖ-ਵੱਖ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ JSON ਤੋਂ 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.