JSON पडताळणी

JSON पडताळणी म्हणजे काय?

JSON (JavaScript ऑब्जेक्ट नोटेशन) हे एक व्यापकपणे स्वीकारलेले, हलके डेटा विनिमय स्वरूप आहे, जे मानवी वाचनीय आणि मशीनसाठी सहज पार्स करण्यास व तयार करण्यास योग्य आहे. यांचा मुख्य उद्देश संरचित डेटा—ऑब्जेक्ट्स, अ‍ॅरे, स्ट्रिंग्स, नंबर, बूलियन्स आणि नल्स—एक भाषानिरपेक्ष पद्धतीने सादर करणे आहे.

JSON मान्यकरण ही एक प्रक्रिया आहे जी प्रोग्रामद्वारे JSON दस्तऐवज व्याकरणानुसार आणि संरचनेनुसार योग्य आहे की नाही हे तपासते. यामध्ये दोन मुख्य बाबींची तपासणी केली जाते:

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

JSON का मान्यता तपासणे का गरजेचे आहे?

जेव्हा डेटा ट्रान्समिशन, साठवण किंवा सेवांमधील संवादासाठी सीरियलाइज केला जातो, तेव्हा JSON वैधता अत्यंत महत्वाची असते. मुख्य कारणे म्हणजे:

• चुक टाळणे: डेटा प्रक्रिया करण्याचा प्रयत्न करण्याआधी लवकरच सिंटॅक्सच्या त्रुटी (उदा., विरामचिन्ह नसणे, जुळणारे कोष्टके नाहीत, बेकायदेशीर वर्ण) ओळखणे आणि अहवाल करणे.
• डेटा अखंडता व सुरक्षा: अयोग्य किंवा दुष्ट JSON पेलोड्स नाकारणे, ज्यामुळे बॅकएंड क्रॅश, इंजेक्शन हल्ले किंवा डेटा भ्रष्ट होण्यापासून प्रतिबंध होतो.
• टाईप सेफ्टी: कडक टायपिंग लागू करा—उदाहरणार्थ, ज्या फील्डला बूलियन अपेक्षित आहे ते स्ट्रिंग म्हणून पाठवले जात नाही याची खात्री करा, किंवा UUIDs, ईमेल्स, किंवा नंबर योग्य स्वरूपात आहेत याची पाठराखण करा.
• क्रॉस-भाषा सुसंगतता: एक वातावरणात (उदा. Node.js) तयार केलेला JSON दुसऱ्या वातावरणात (उदा. Python, Go, Java) सुरक्षितपणे वापरता येईल याची हमी द्या, ज्यामुळे सिरियलायझेशन/डिसिरियलायझेशनमधील त्रुटी टाळता येतील.
• देखभाल सुलभता आणि मजबुती: तपासलेली डेटा रचना ट्रेस करण्यास सुलभता वाढवतात आणि कॉन्फिगरेशन फाइल्स, लॉग्ज किंवा API विनंत्या/प्रत्युत्तरांमधील त्रुटी शोधण्याचे धोक्य कमी करतात.
• गोपनीयता आणि सुरक्षा: पडताळणी पूर्णपणे क्लायंट-साइड (ब्राउझरमध्ये) केली जाऊ शकते, ज्यामुळे वापरकर्त्याच्या डिव्हाइसवरून कोणतीही रॉ किंवा संवेदनशील माहिती पडताळणीसाठी बाहेर जात नाही.

सामान्य JSON वैधता त्रुटी (सविस्तर उदाहरणांसह)

अकोटेड की

JSON ऑब्जेक्टमधील सर्व कीज डबल कोटेशन्समध्ये असाव्यात.

{ name: "एलिस" }

{ "name": "अॅलिस" }

अनेक JSON-समान फॉरमॅट्स (उदा. JavaScript ऑब्जेक्ट लिटरल्स) अनकोटेड कीजला परवानगी देतात, पण मानक JSON त्याला परवानगी देत नाही.

सिंगल कोट्स

JSON स्ट्रिंगमध्ये फक्त डबल कोट्स वापरावेत; सिंगल कोट्स वापरण्याची परवानगी नाही.

{ 'name': 'बॉब' }

{ "name": "बॉब" }

एकली कोट्स वापरल्यास सर्व संगत JSON लायब्ररींमध्ये पार्सर त्रुटी दिसतील.

शेवटच्या कोष्ठकापूर्वी कॉमा

ऑब्जेक्ट किंवा अ‍ॅरेमधील शेवटच्या आयटमनंतर कोणतीही कॉमा वापरू नका.

{
  "a": १,
  "b": २,
}

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

JavaScript मध्ये ट्रेलिंग कॉमा काम करू शकतात, परंतु कडक JSON पार्सरमध्ये ते चालत नाहीत.

अयोग्य अक्षरे पलटी करणे

स्ट्रिंगमधील कोट्स आणि विशेष अक्षरे बॅकस्लॅश वापरून एस्केप करणे आवश्यक आहे.

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

{ "quote": "टॉमने सांगितले \"नमस्कार\"" }

इतर पलायन अनुक्रमांमध्ये बॅकस्लॅशसाठी \\, नवीन ओळींसाठी \n, आणि टॅबसाठी \t यांचा समावेश होतो.

चुकीचे डेटा प्रकार

संख्या, बूलियन किंवा शून्य यासाठी स्ट्रिंग वापरू नयेत.

{ "enabled": "खरे", "count": "१०" }

{ "enabled": खरे, "count": १० }

JSON बूलियन, संख्या आणि स्ट्रिंग यामध्ये फरक करतो—योग्य प्रकार वापरल्याची खात्री करा.

गैर-मूळ की

JSON ऑब्जेक्ट की नेहमीच स्ट्रिंग स्वरूपात असाव्यात; तुम्ही की म्हणून संख्या, बूलियन किंवा इतर प्रकार वापरू शकत नाही.

{ 123: "अबी" }

{ "123": "अ‍ॅबसी" }

डुप्लिकेट कीज

JSON स्पेकनुसार परवानगी असली तरी, डुप्लिकेट कीज त्रुटींचे सामान्य कारण असतात.

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

बहुतेक पार्सर्स फक्त शेवटचा मूल्य ("बॉब") ठेवतात आणि आधीचे मूल्य शांतपणे वगळतात.

टिप्पण्यांचा वापर

स्टॅंडर्ड JSON टिप्पण्यांना परवानगी देत नाही, जरी काही संपादक ते समर्थित करत असतील तरीही.

{
  // वापरकर्ता माहिती
  "name": "एलीस"
}

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

स्कीमा प्रमाणीकरण: रचना आणि डेटा प्रकारांची अंमलबजावणी

JSON स्कीमा हे 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 (ऐच्छिक) हा एक बूलियन असायला हवा.
• वरील परिभाषित केलेल्या मालमत्तांव्यतिरिक्त इतर कोणतीही मालमत्ता मान्य नाही.

खरा उदाहरण: Stripe API प्रतिसादांची सत्यता तपासणे

समजा तुम्हाला Stripe API कडून JSON प्रतिसाद मिळतात (उदा. PaymentIntent). Schema पडताळणीमुळे तुम्ही कधीही अपूर्ण किंवा चुकीच्या प्रकारातील डेटा प्रक्रिया करत नाही याची खात्री करता येते.

{
  "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 पाइपलाइनमध्ये स्कीमांचा वापर करा.
• क्रॉस-टीम सुसंगतता: फ्रंटएंड, बॅकएंड आणि तृतीय-पक्ष API दरम्यान डेटाचे करार प्रमाणित करा.

योग्य 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)
  }
}

या साधना विषयी