JSON માન્યતા ચકાસક

JSON માન્યકરણ શું છે?

JSON (જાવાસ્ક્રિપ્ટ ઓબ્જેક્ટ નોટેશન) એક વ્યાપક રીતે અપનાવવામાં આવેલું, હલકું અને કાર્યક્ષમ ડેટા-ઇન્ટરચેન્જ ફોર્મેટ છે, જે માનવ માટે વાંચવા યોગ્ય અને મશીનો માટે સરળતાથી પાર્સ અને જનરેટ કરવા માટે ડિઝાઇન કરવામાં આવ્યું છે. તેનો મુખ્ય ઉદેશ્ય રચાયેલ ડેટા—ઓબ્જેક્ટ્સ, એરે, સ્ટ્રિંગ્સ, સંખ્યાઓ, બૂલિયન અને નલ—ને ભાષા-નિષ્પક્ષ રીતે પ્રતીકિત કરવો છે.

JSON માન્યકરણ એ પ્રક્રિયા છે જેમાં કાર્યક્રમને ઉપયોગ કરીને તપાસવામાં આવે છે કે JSON દસ્તાવેજ વ્યાકરણાત્મક અને બાંયધરી રીતે યોગ્ય છે કે નહીં. આમાં મુખ્ય två બાબતોની ચકાસણી થાય છે:

• વ્યાકરણિક ચકાસણી: પકિતાં લખાણ એસી એમ એ-404 JSON સ્પેસિફિકેશન દ્વારા નિર્ધારિત ઔપચારિક વ્યાકરણનું પાલન કરે તે ખાતરી કરવી. આધુનિક પ્રોગ્રામિંગ ભાષાઓનાં મોટાભાગના પાર્સર્સ (જેમ કે, જાવાસ્ક્રિપ્ટમાં JSON.parse(), પાયથનમાં json.loads(), જવામાં JSONDecoder) વૈધ સિન્ટેક્સની અપેક્ષા રાખે છે અને જો ઈનપુટ ખોટું હોય તો ભૂલો બતાવે છે.
• ડાથેલ (સ્કીમા) માન્યકરણ: સિંટેક્સથી આગળ, સ્કીમા માન્યતા ચકાસે છે કે JSON ડેટા અપેક્ષિત માળખા સાથે મેળ ખાય છે, જેમાં ડેટા પ્રકારો, જરૂરી ગુણધર્મો, મુલ્ય મર્યાદાઓ અને નેસ્ટેડ ઑબ્જેક્ટ/એરે શામેલ છે. સ્કીમા માન્યતા સામાન્ય રીતે JSON સ્કીમા નો ઉપયોગ કરીને કરવામાં આવે છે, જે માન્ય ડેટા માટેના નિયમો નિર્દેશિત કરે છે.

JSON કેમ માન્ય વાયરવું પડે?

ડેટા પ્રસારણ, સંગ્રહ અથવા ઇન્ટર-સર્વિસ સંચાર માટે ડેટા સિરીયલાઇઝ કરતી વખતે JSON વેલિડેશન ખૂબ જ મહત્વપૂર્ણ છે. મુખ્ય કારણો આ પ્રમાણે છે:

• ભૂલ નિવારણ: સિન્સટેક્સની ભૂલો (જેમ કે ગૂમ થયેલા કમા, અસંગત બ્રેકેટ્સ, અનૈતિક અક્ષરો) વહેલી તકે શોધો અને રિપોર્ટ કરો—ડેટા પ્રોસેસ કરવાનો પ્રયત્ન કરવાની પહેલા.
• ડેટા નિષ્ઠા અને સુરક્ષા: ખોટા અથવા દુર્ભાવનાપૂર્વકના JSON પેઇલોએડ્સને અસ્વીકારો, જેથી બેકએન્ડ ક્રેશ, ઈન્જેક્શન હુમલો અથવા ડેટા કરપ્શનથી બચી શકાય.
• પ્રકાર સલામતી: કડક ટાઇપિંગ લાગુ કરો—ઉદાહરણ તરીકે, કોઈ ફીલ્ડ કે જે બુલિયન હોવાની અપેક્ષા હોય તે સ્ટ્રિંગ તરીકે ન મોકલાય, અથવા UUID, ઇમેઇલ, અથવા નંબર યોગ્ય ફોર્મેટનું પાલન કરે તે સુનિશ્ચિત કરો.
• ભાષા પારસ્પરિક સુમેળ: ખાતરી કરો કે એક પર્યાવરણ (જેમ કે Node.js) માં ઉત્પન્ન થયેલું JSON બીજામાં (જેમ કે Python, Go, Java) સુરક્ષિત રીતે ઉપયોગ કરી શકાય, જેથી સીરિયલાઇઝેશન/ડીસીરિયલાઇઝેશન બગ્સ ટળી શકે.
• રુપરેખા અને મજબૂતાઈ: માન્ય કરેલી ડેટા રચનાઓ ટ્રેસેબિલિટીમાં સુધારો લાવે છે અને કન્ફિગરેશન ફાઇલો, લોગ્સ, અથવા API વિનંતીઓ/જવાબમાં કઠણાઈથી ડિબગ થનારા સમસ્યાઓનું જોખમ ઘટાડે છે.
• ગોપનીયતા અને સુરક્ષા: ચકાસણી સંપૂર્ણપણે ગ્રાહક-પાર્થિવ (બ્રાઉઝરમાં) કરવામાં આવી શકે છે, જે વપરાશકર્તાના ઉપકરણમાંથી કાચા અથવા સંવેદનશીલ ડેટાને બહાર જવાથી રોકે છે.

સામાન્ય JSON માન્યતા ભૂલો (વિસ્તૃત ઉદાહરણો સાથે)

અવોક્ત કી અને વર્ણન

JSON ઑબ્જેક્ટમાં બધી ચાંવનીઓ ડબલ કોષ્ઠક ચિહ્નવાળી સ્ટ્રિંગ હોવી જરૂરી છે.

{ name: "એલિસ" }

{ "name": "એલિસ" }

ઘણા JSON જેવા ફોર્મેટ્સ (જેમ કે, જાવાસ્ક્રિપ્ટ ઓબ્જેક્ટ લિટરલ્સ) ક્વોટ વગર કી_ALLOW કરે છે, પરંતુ સ્ટાન્ડર્ડ JSON તે નથી_ALLOW કરતો.

એકલ અવરોધક પુરુષાર્થ

JSON સ્ટ્રિંગ્સમાં માત્ર ડબલ ક્વોટ્સનો ઉપયોગ કરવો જ જરૂરી છે; સિંગલ ક્વોટ્સ માન્ય નથી.

{ 'name': 'બોબ' }

{ "name": "બોબ" }

એકલ quotes નો ઉપયોગ કરતી વખતે તમામ અનુરૂપ JSON લાયબ્રેરીઝમાં પાર્સર ત્રુટિઓ આવશે.

પાછળ kommaો

ઓબ્જેક્ટ અથવા એરેમાં છેલ્લા આઈટમ પછી કમાનો ઉપયોગ ન કરવો.

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

{
  "a": ૧,
  "b": ૨
}

ટ્રેઇલિંગ કોમાસ જાવાસ્ક્રિપ્ટમાં કાર્યરત હોઈ શકે છે, પરંતુ કડક JSON పార્સર્સમાં કામ કરતા નથી.

અણસારવાદી અક્ષરોએ યોગ્ય રીતે ન બહુચિત કરવું

સ્ટ્રિંગ્સની અંદર ક્વોટ્સ અને વિશેષ અક્ષરોને બેકસ્લેશનો ઉપયોગ કરીને એસ્કેપ કરવું જરૂરી છે.

{ "quote": "ટોમએ કહ્યું \"હેલ્લો\"" }

{ "quote": "ટૉમએ કહ્યું \"હેલો\"" }

અન્ય અગમ્ય ક્રમોમાં બેકસ્લેશ માટે \\ , નવી પંક્તિ માટે \n , અને ટેબ માટે \t શામેલ છે.

અયોગ્ય ડેટા પ્રકાર

સંખ્યાઓ, બૂલિયન અથવા નોલ માટે સ્ટ્રિંગ વાપરવી જોઈએ નથી.

{ "enabled": "સક્રિય", "count": "૧૦" }

{ "enabled": true, "count": 10 }

JSON બુલિયન, સંખ્યાઓ અને સ્ટ્રિંગ વચ્ચે પારેક differentiates કરે છે—સૂચિત કરો કે યોગ્ય પ્રકારનો ઉપયોગ થાય છે.

અપ્રાથમિક કીઓ

JSON ઓબ્જેક્ટ કીઝ હંમેશા સ્ટ્રિંગ હોવી જોઈએ; તમે કીઝ માટે સંખ્યા, બૂલિયન, અથવા અન્ય પ્રકારો ઉપયોગ કરી શકતા ના હો.

{ 123: "એબીસી" }

{ "123": "એબીસી" }

નকল કીઓ

જ્યારે JSON સ્પષ્ટીકરણอนુસાર અનુમતિ આપવામાં આવે છે, ડુપ્લિકેટ કી સામાન્ય રીતે બગ્સનું મુખ્ય કારણ હોય છે.

{ "name": "એલિસ", "name": "બોબ" }

ઘણા પાર્સર્સ ફક્ત છેલ્લું મૂલ્ય("બોબ") જ રાખશે અને પહેલાંના મૂલ્યોને ચुपચાપ નકારી નાખશે.

ટિપ્પણીઓનો ઉપયોગ

સ્ટાન્ડર્ડ JSONમાં કોમેન્ટ્સ દેવાની પરવાનગી નથી, હાળાં કે કેટલાક એડિટરો એમનું સમર્થન કરે છે.

{
  // વપરાશકર્તા માહિતી
  "name": "એલિસ"
}

{
  "name": "એલિસ"
}

સ્કીમા ચકાસણી: બનાવટ અને ડેટા પ્રકારોની પુષ્ટિ કરવી

JSON સ્કીમા એ JSON દસ્તાવેજોની અપેક્ષિત રચનાને વ્યાખ્યાયિત અને માન્ય કરવાની માટે એક શક્તિશાળી ધોરણ છે. તે તમને નિર્દેશ કરવાનું આપે છે:

• જરૂરી ક્ષેત્રો (`required`)
• ડેટા પ્રકારો (`type`: સ્ટ્રિંગ, નંબરસંખ્યાઓ, બૂલિયન, ઑબ્જેક્ટ, એરે, નલ)
• સ્ટ્રિંગ ફોર્મેટ્સ (`ફોર્મેટ`: ઈમેલ, યુયુઆઇડી, તારીખ-સમય, વગેરે)
• સ્ટ્રિંગ્સ માટે પેટર્ન મેચિંગ (`pattern`)
• સંખ્યા શ્રેણીઓ (`ન્યુનતમ`, `અધિકતમ`)
• એરે લંબાઈ અને આઇટમ વેલિડેશન (`minItems`, `maxItems`, `items`)
• ઑબ્જેક્ટ અને જેવાંગીઓ માટે નેસ્ટેડ માન્યતા
• એનમ નિયમો (`enum`)

ઉદાહરણ: યુઝર સ્કીમા (ડ્રાફ્ટ-૦૭)

{
  "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 પાઇપલાઇન્સમાં સ્કીમાઓનો ઉપયોગ કરો.
• ક્રોસ-ટીમ સુસંગતતા: ફ્રન્ટએન્ડ, બેકએન્ડ અને તૃતીય પક્ષ API વચ્ચે ડેટા કરારને ધોરણબદ્ધ બનાવો.

યોગ્ય JSON માન્યતાને આગળ રાખવું—જેમ કે વિધાનશાસ્ન અને સ્કીમા બંનેને આવરી લેવી—સૂક્ષ્મ ભૂલોને રોકે છે, શ્રેષ્ઠ પ્રથા ને અમલમાં લાવે છે, અને તમારા એપ્લિકેશનોને ખોટા અથવા દુર્ભાવનાપૂર્ણ ઇનપુટથી સુરક્ષિત બનાવે છે. કોન્ફિગરેશન ફાઈલો, API પેલોડ, કે ઇન્ટર-સર્વિસ સંદેશાવ્યવહારમાં ઉપયોગ કરવામાં આવે તેવા દ્રષ્ટિથી, મજબૂત માન્યતા આધુનિક સોફ્ટવેર સિસ્ટમ્સ માટે મહત્વપૂર્ણ આધાર છે.

ગુપ્તતા અને સુરક્ષા

બધા ચકાસણી અને સ્કીમા ચેક્સ તમારી બ્રાઉઝરમાં સ્થાનિક સ્તરે ચાલે છે. કોઈપણ ડેટા અપલોડ કે લૉગ કરાતો નથી. તમારું JSON સંપૂર્ણ રીતે ખાનગી રહે છે.

JSON માન્યતા માટે કોડ ઉદાહરણો

આંતરિક લાઇબ્રેરીઝ અથવા લોકપ્રિય ફ્રેમવર્ક્સનો ઉપયોગ કરીને વિવિધ પ્રોગ્રામિંગ ભાષાઓમાં JSON કેવી રીતે માન્યતા આપવી તે જુઓ. આ ઉદાહરણો syntax માન્યતા અને સ્કીમા માન્યતા બંને બતાવે છે.

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)
  }
}

આ ટૂલ વિશે