JSON मान्यकर्ता

JSON सत्यापन क्या है?

JSON (जावास्क्रिप्ट ऑब्जेक्ट नोटेशन) एक व्यापक रूप से अपनाया गया, हल्का डेटा-इंटरचेंज फॉर्मेट है, जिसे मनुष्यों के लिए पठनीय और मशीनों के लिए पार्स करने तथा जनरेट करने में आसान बनाने के लिए डिज़ाइन किया गया है। इसका मुख्य उद्देश्य संरचित डेटा—ऑब्जेक्ट, एरे, स्ट्रिंग, नंबर, बूलियन, और नल—को भाषा-स्वतंत्र तरीके से प्रस्तुत करना है।

JSON सत्यापन एक प्रक्रिया है जिसमें प्रोग्राम के माध्यम से यह सुनिश्चित किया जाता है कि JSON दस्तावेज़ व्याकरणिक (सिंटैक्स) और संरचनात्मक रूप से सही है। इसमें दो मुख्य पहलुओं की जांच शामिल होती है:

• सांकेतिक सत्यापन: यह सुनिश्चित करना कि कच्चा पाठ ECMA-404 JSON विनिर्देशन द्वारा परिभाषित औपचारिक व्याकरण का पालन करता है। अधिकांश आधुनिक प्रोग्रामिंग भाषाओं के पार्सर (जैसे, JavaScript में JSON.parse(), Python में json.loads(), Java में JSONDecoder) वैध वाक्य-विन्यास की अपेक्षा करते हैं और यदि इनपुट गलत स्वरूपित होता है तो त्रुटियाँ उत्पन्न करते हैं।
• संरचनात्मक (स्कीमा) सत्यापन: सिंटैक्स से परे, स्कीमा जांच यह सुनिश्चित करती है कि JSON डेटा अपेक्षित संरचना से मेल खाता है, जिसमें डेटा प्रकार, आवश्यक गुण, मान सीमाएँ, और नेस्टेड ऑब्जेक्ट/एरे शामिल हैं। स्कीमा जांच आमतौर पर JSON स्कीमा का उपयोग करके की जाती है, जो यह निर्धारित करता है कि कौन सा डेटा वैध माना जाता है।

JSON मान्य क्यों करें?

जब भी डेटा को ट्रांसमिशन, स्टोरेज, या इंटर-सर्विस संचार के लिए सीरियलाइज़ किया जाता है, तो JSON सत्यापन बेहद महत्वपूर्ण होता है। इसके प्रमुख कारण हैं:

• त्रुटि रोकथाम: सिंटैक्स त्रुटियों (जैसे, गायब कॉमा, असंगत ब्रैकेट्स, अवैध अक्षर) का जल्दी पता लगाएं और रिपोर्ट करें—डेटा प्रक्रिया करने से पहले।
• डेटा अखंडता और सुरक्षा: अक्षम या दुर्भावनापूर्ण JSON पेलोड्स अस्वीकार करें, जिससे बैकएंड क्रैश, इंजेक्शन हमलों या डेटा भ्रष्टाचार को रोका जा सके।
• टाइप सुरक्षा: सख्त टाइपिंग लागू करें—उदाहरण के लिए, यह सुनिश्चित करें कि किसी फ़ील्ड को जो boolean होना चाहिए वह string के रूप में न भेजा जाए, या UUID, ईमेल, या नंबर सही प्रारूप में हों।
• क्रॉस-भाषा संगतता: यह सुनिश्चित करें कि एक वातावरण (जैसे, Node.js) में उत्पन्न JSON को दूसरे वातावरण (जैसे, Python, Go, Java) में सुरक्षित रूप से उपयोग किया जा सके, जिससे सीरियलाइज़ेशन/डीसिरियलाइज़ेशन की त्रुटियों से बचा जा सके।
• मेन्टेनेबिलिटी और मजबूती: सत्यापित डेटा संरचनाएं ट्रैसेबिलिटी को बेहतर बनाती हैं और कॉन्फ़िगरेशन फ़ाइलों, लॉग्स, या API अनुरोध/प्रतिक्रियाओं में डिबग करने में कठिन त्रुटियों का जोखिम कम करती हैं।
• प्राइवेसी और सुरक्षा: सत्यापन पूरी तरह से क्लाइंट-साइड (ब्राउज़र में) किया जा सकता है, जिससे कच्चा या संवेदनशील डेटा उपयोगकर्ता के डिवाइस से सत्यापन के लिए बाहर नहीं जाता।

सामान्य JSON वैधता त्रुटियाँ (विस्तृत उदाहरणों के साथ)

बिना उद्धरण वाले कुंजी

JSON वस्तुओं में सभी कुंजी डबल-कोटेड स्ट्रिंग्स होनी चाहिए।

{ name: "एलिस" }

{ "name": "एलिस" }

कई JSON-समान प्रारूप (जैसे, JavaScript ऑब्जेक्ट लिटरेलक) बिना उद्धरण के कीज़ की अनुमति देते हैं, लेकिन मानक JSON में ऐसा संभव नहीं है।

सिंगल कोट्स

JSON स्ट्रिंग्स में केवल डबल कोट्स का उपयोग होना चाहिए; सिंगल कोट्स की अनुमति नहीं है।

{ 'name': 'बॉब' }

{ "name": "बॉब" }

एकल उद्धरण चिह्नों का उपयोग करने से सभी अनुरूप JSON लाइब्रेरीज़ में पार्सर त्रुटियाँ होंगी।

अंतिम कॉमा

ऑब्जेक्ट या एरे में अंतिम आइटम के बाद कोई अतिरिक्त कॉमा न हो।

{
  "a": 1,
  "b": 2,
}

{
  "a": 1,
  "b": 2
}

ट्रेलिंग कॉमा JavaScript में काम कर सकते हैं, लेकिन सख्त JSON पार्सर्स में नहीं चलेंगे।

अक्षरों का अनुचित एस्केपिंग

स्ट्रिंग्स के अंदर उद्धरण चिह्न और विशेष अक्षरों को बैकस्लैश का उपयोग करके एस्केप किया जाना चाहिए।

{ "quote": "टॉम ने कहा \"नमस्ते\"" }

{ "quote": "टॉम ने कहा \"नमस्ते\"" }

अन्य एस्केप अनुक्रमों में बैकस्लैश के लिए \\ , नई लाइनों के लिए \n , और टैब के लिए \t शामिल हैं।

गलत डेटा प्रकार

संख्याओं, बुलियन मानों या null के लिए स्ट्रिंग्स का उपयोग नहीं करना चाहिए।

{ "enabled": "सक्रिय", "count": "10" }

{ "सक्रिय": true, "गणना": 10 }

JSON बूलियन, नंबर, और स्ट्रिंग्स में अंतर करता है—सुनिश्चित करें कि सही प्रकार का उपयोग हो।

गैर-प्राथमिक कुंजी

JSON ऑब्जेक्ट की चाभियाँ हमेशा स्ट्रिंग्स होनी चाहिए; आप संख्या, बूलियन या अन्य प्रकार की चाबियाँ के रूप में उपयोग नहीं कर सकते।

{ 123: "एबीसी" }

{ "123": "एबीसी" }

डुप्लिकेट कुंजियाँ

हालांकि JSON विनिर्देश द्वारा अनुमति है, डुप्लिकेट कुंजी अक्सर बग्स का सामान्य स्रोत होती हैं।

{ "name": "एलिस", "name": "बॉब" }

अधिकांश पार्सर केवल अंतिम मान ("Bob") को ही रखेंगे, पूर्व के मानों को चुपचाप छोड़ देते हैं।

टिप्पणियों का उपयोग

मूल JSON में टिप्पणियाँ अनुमति नहीं होतीं, हालांकि कुछ संपादक इन्हें सपोर्ट करते हैं।

{
  // उपयोगकर्ता जानकारी
  "name": "एलिस"
}

{
  "name": "ऐलिस"
}

स्कीमा सत्यापन: संरचना और डेटा प्रकारों को लागू करना

JSON Schema एक शक्तिशाली मानक है जो JSON दस्तावेज़ों की अपेक्षित संरचना को परिभाषित और सत्यापित करने के लिए उपयोग किया जाता है। यह आपको निम्नलिखित निर्दिष्ट करने की अनुमति देता है:

• आवश्यक फ़ील्ड (`required`)
• डेटा प्रकार (`type`: स्ट्रिंग, संख्या, बूलियन, ऑब्जेक्ट, ऐरे, नल)
• स्ट्रिंग प्रारूप (`format`: ईमेल, UUID, दिनांक-समय, आदि)
• स्ट्रिंग के लिए पैटर्न मिलान (`pattern`)
• संख्या सीमा (`न्यूनतम`, `अधिकतम`)
• एरे की लंबाई और आइटम सत्यापन (`minItems`, `maxItems`, `items`)
• ऑब्जेक्ट्स और ऐरेज़ के लिए नेस्टेड सत्यापन
• एन्‍म प्रतिबंध (`enum`)

उदाहरण: उपयोगकर्ता स्कीमा (ड्राफ्ट-07)

{
  "type": "object",
  "properties": {
    "id":    { "type": "string", "format": "uuid" },
    "name":  { "type": "string", "minLength": 1 },
    "email": { "type": "string", "format": "email" },
    "is_active": { "type": "boolean" }
  },
  "required": ["id", "name", "email"],
  "additionalProperties": false
}

यह क्या लागू करता है:

• आईडी एक मान्य UUID स्ट्रिंग होनी चाहिए।
• नाम एक खाली न होने वाला वर्णमाला स्ट्रिंग होना चाहिए।
• ईमेल का प्रारूप मानक ईमेल फॉर्मेट से मेल खाना चाहिए।
• is_active (वैकल्पिक) एक बूलियन होना चाहिए।
• उपरोक्त परिभाषित संपत्तियों के अलावा अन्य कोई गुण अनुमति नहीं हैं।

वास्तविक उदाहरण: स्ट्राइप API प्रतिक्रियाओं की प्रमाणीकरण

मान लीजिए आप Stripe API (जैसे PaymentIntent) से JSON प्रतिक्रियाएं प्राप्त करते हैं। स्कीमा सत्यापन सुनिश्चित करता है कि आप कभी भी अधूरी या गलत प्रकार की डेटा को संसाधित न करें।

{
  "type": "object",
  "properties": {
    "id":      { "type": "string", "pattern": "^pi_" },
    "object":  { "type": "string", "const": "payment_intent" },
    "amount":  { "type": "integer", "minimum": 1 },
    "currency":{ "type": "string", "minLength": 3, "maxLength": 3 },
    "status":  { "type": "string", "enum": [
      "भुगतान_विधि_आवश्यक",
      "पुष्टि_आवश्यक",
      "प्रोसेसिंग",
      "सफल",
      "रद्द"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• आईडी "pi_" से शुरू होनी चाहिए
• ऑब्जेक्ट हमेशा "payment_intent" होना चाहिए
• राशि एक पूर्णांक होनी चाहिए जो 1 या उससे अधिक हो
• मुद्रा एक तीन-अक्षरी स्ट्रिंग होनी चाहिए (जैसे, "usd", "eur")
• स्थिति निर्दिष्ट मानों में से एक होनी चाहिए

लाभ

• प्रारंभिक त्रुटि पहचान: अपनी व्यावसायिक लॉजिक तक पहुंचने से पहले API में हुई महत्वपूर्ण बदलावों या अधूरी जानकारी को पकड़ें।
• स्वचालित परीक्षण: वास्तविक और मॉक प्रतिक्रियाओं को मान्य करने के लिए CI/CD पाइपलाइनों में स्कीमाओं का उपयोग करें।
• टीमों के बीच समरसता: फ्रंटएंड, बैकएंड और थर्ड-पार्टी APIs के बीच डेटा कॉन्ट्रैक्ट्स को मानकीकृत करें।

सटीक JSON सत्यापन—जिसमें सिंटैक्स और स्कीमा दोनों शामिल हैं—सूक्ष्म बग्स को रोकता है, सर्वोत्तम प्रथाओं को लागू करता है, और आपके एप्लिकेशनों को गलत या दुर्भावनापूर्ण इनपुट से सुरक्षित रखता है। चाहे यह कॉन्फ़िगरेशन फाइलों, API पेलोड्स, या इंटर-सर्विस मैसेजिंग में उपयोग हो, मजबूत सत्यापन आधुनिक सॉफ्टवेयर सिस्टम्स के लिए मौलिक आधार है।

गोपनीयता और सुरक्षा

सभी सत्यापन और योजना जांच आपके ब्राउज़र में स्थानीय रूप से चलती हैं। कोई भी डेटा अपलोड या लॉग नहीं किया जाता है। आपका JSON पूरी तरह से निजी रहता है।

JSON सत्यापन के लिए कोड उदाहरण

बिल्ट-इन लाइब्रेरीज या लोकप्रिय फ्रेमवर्क का उपयोग करके विभिन्न प्रोग्रामिंग भाषाओं में JSON को कैसे मान्य करें, देखें। ये उदाहरण सिंटैक्स सत्यापन और स्कीमा सत्यापन दोनों को प्रदर्शित करते हैं।

const jsonString = '{"name":"Alice","age":30}';
try {
  const obj = JSON.parse(jsonString);
  console.log("Valid JSON:", obj);
} catch (e) {
  console.error("Invalid JSON!", e.message);
}

const Ajv = require("ajv");
const ajv = new Ajv();
const schema = { type: "object", properties: { age: { type: "integer" } }, required: ["age"] };
const data = { age: 30 };
const validate = ajv.compile(schema);
console.log(validate(data) ? "Valid!" : ajv.errorsText(validate.errors));

import json
try:
    obj = json.loads('{"name":"Alice","age":30}')
    print("Valid JSON:", obj)
except json.JSONDecodeError as e:
    print("Invalid JSON:", e)

import json, jsonschema
schema = {
    "type": "object",
    "properties": { "age": { "type": "integer" } },
    "required": ["age"]
}
data = {"age": 30}
try:
    jsonschema.validate(data, schema)
    print("Valid!")
except jsonschema.ValidationError as e:
    print("Schema validation error:", e)

package main
import (
  "encoding/json"
  "fmt"
)
func main() {
  data := []byte(`{"name":"Alice","age":30}`)
  var obj map[string]interface{}
  if err := json.Unmarshal(data, &obj); err != nil {
    fmt.Println("Invalid JSON:", err)
  } else {
    fmt.Println("Valid JSON:", obj)
  }
}

import com.fasterxml.jackson.databind.ObjectMapper;
public class Main {
  public static void main(String[] args) {
    String json = "{"name":"Alice","age":30}";
    try {
      Object obj = new ObjectMapper().readTree(json);
      System.out.println("Valid JSON: " + obj);
    } catch (Exception e) {
      System.out.println("Invalid JSON: " + e.getMessage());
    }
  }
}

using System;
using System.Text.Json;
class Program {
  static void Main() {
    string json = "{"name":"Alice","age":30}";
    try {
      var doc = JsonDocument.Parse(json);
      Console.WriteLine("Valid JSON!");
    } catch (JsonException e) {
      Console.WriteLine("Invalid JSON: " + e.Message);
    }
  }
}

<?php
$json = '{"name":"Alice","age":30}';
$obj = json_decode($json);
if (json_last_error() === JSON_ERROR_NONE) {
  echo "Valid JSON";
} else {
  echo "Invalid JSON: " . json_last_error_msg();
}

require 'json'
begin
  obj = JSON.parse('{"name":"Alice","age":30}')
  puts "Valid JSON!"
rescue JSON::ParserError => e
  puts "Invalid JSON: #{e.message}"
end

echo '{"name":"Alice","age":30}' | jq empty && echo "Valid" || echo "Invalid"

fn main() {
  let data = r#"{"name":"Alice","age":30}"#;
  match serde_json::from_str::<serde_json::Value>(data) {
    Ok(_) => println!("Valid JSON!"),
    Err(e) => println!("Invalid JSON: {}", e),
  }
}

import org.json.JSONObject
fun main() {
  try {
    val obj = JSONObject("{\"name\":\"Alice\",\"age\":30}")
    println("Valid JSON: $obj")
  } catch (e: Exception) {
    println("Invalid JSON: ${e.message}")
  }
}

import Foundation
let json = "{\"name\":\"Alice\",\"age\":30}"
if let data = json.data(using: .utf8) {
  do {
    let _ = try JSONSerialization.jsonObject(with: data)
    print("Valid JSON!")
  } catch {
    print("Invalid JSON: \(error)")
  }
}

const jsonString = '{"name":"Alice","age":30}';
try {
  const obj = JSON.parse(jsonString);
  console.log("Valid JSON:", obj);
} catch (e) {
  console.error("Invalid JSON!", e.message);
}

SELECT '{"name":"Alice","age":30}'::jsonb; -- Will error if not valid JSON

SELECT JSON_VALID('{"name":"Alice","age":30}');

$json = '{"name":"Alice","age":30}'
try {
  $obj = $json | ConvertFrom-Json
  Write-Output "Valid JSON!"
} catch {
  Write-Output "Invalid JSON: $($_.Exception.Message)"
}

use JSON;
my $str = '{"name":"Alice","age":30}';
eval { decode_json($str) };
print $@ ? "Invalid JSON: $@" : "Valid JSON!";

import 'dart:convert';
void main() {
  const jsonString = '{"name":"Alice","age":30}';
  try {
    final obj = jsonDecode(jsonString);
    print('Valid JSON: $obj');
  } catch (e) {
    print('Invalid JSON: $e');
  }
}

json = ~s({"name":"Alice","age":30})
case Jason.decode(json) do
  {:ok, _} -> IO.puts("Valid JSON!")
  {:error, err} -> IO.puts("Invalid JSON: #{err}")
end

import play.api.libs.json._
object Main extends App {
  val str = """{"name":"Alice","age":30}"""
  try {
    val json = Json.parse(str)
    println("Valid JSON!")
  } catch {
    case e: Exception => println("Invalid JSON: " + e.getMessage)
  }
}

इस उपकरण के बारे में