JSON ویلیڈیٹر

JSON کی توثیق کیا ہے؟

JSON (جاوا اسکرپٹ آبجیکٹ نوٹیشن) ایک وسیع پیمانے پر اپنایا گیا، ہلکا پھلکا ڈیٹا-انٹرسچینج فارمیٹ ہے، جو انسانوں کے لئے پڑھنے میں آسان اور مشینوں کے لیے تجزیہ اور تخلیق کرنے میں سہولت دیتا ہے۔ اس کا بنیادی مقصد ساختہ ڈیٹا—جیسے کہ آبجیکٹس، ارریز، سٹرنگز، نمبر، بولینز، اور نیل ویلیوز کو زبان سے آزاد انداز میں نمائندگی کرنا ہے۔

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) میں محفوظ طریقے سے استعمال ہو سکے، تاکہ serialization/deserialization کے مسائل سے بچا جا سکے۔
• قابل نگہداشت اور مضبوطی: تصدیق شدہ ڈیٹا ڈھانچے ٹریسبلٹی کو بہتر بناتے ہیں اور کنفیگریشن فائلز، لاگز، یا API درخواستوں/جوابات میں مشکل سے ٹھیک ہونے والی غلطیوں کے خطرے کو کم کرتے ہیں۔
• رازداری اور سلامتی: تصدیق مکمل طور پر کلائنٹ سائڈ (براؤزر میں) کی جا سکتی ہے، جس سے صارف کے آلہ سے حساس یا خام ڈیٹا کے باہر جانے سے روکا جاتا ہے۔

عام JSON کی تصدیقی غلطیاں (تفصیلی مثالوں کے ساتھ)

غیر محصور کلیدیں

JSON آبجیکٹس میں تمام کیز کو ڈبل کوٹیشن مارکس کے ساتھ محاط ہونا ضروری ہے۔

{ name: "ایلس" }

{ "name": "ایلس" }

بہت سے JSON جیسے فارمیٹس (مثلاً JavaScript آبجیکٹ لیٹرلز) بغیر اقتباسات کے کیز کی اجازت دیتے ہیں، لیکن معیاری JSON میں یہ ممکن نہیں ہے۔

واحد اقتباسات

JSON اسٹرنگز میں صرف ڈبل کوٹس استعمال کیے جاتے ہیں؛ سنگل کوٹس کی اجازت نہیں ہے۔

{ 'name': 'بوب' }

{ "name": "بوب" }

سنگل کوٹس کے استعمال سے تمام معیاری JSON لائبریریوں میں پارسر کی غلطیاں ہوں گی۔

آخری کامے

آبجیکٹ یا اررے میں آخری آئٹم کے بعد کوئی اضافی کومہ نہیں لگائیں۔

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

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

JavaScript میں trailing commas چل سکتے ہیں، لیکن سخت JSON parsers میں نہیں چلتے۔

کریکٹرز کی غلط طور پر اسکیپنگ

اسٹرنگز کے اندر قوسین اور خصوصی حروف کو بیک سلیش کے ذریعے محفوظ کرنا ضروری ہے۔

{ "quote": "ٹام نے کہا 'ہیلو'" }

{ "quote": "ٹام نے کہا \"ہیلو\"" }

دیگر ایگزیکیوٹ سیکوینسز میں بیک سلیش کے لئے \\، نئی لائن کے لئے \n، اور ٹیب کے لئے \t شامل ہیں۔

غلط ڈیٹا ٹائپس

اعداد، بولین یا نیل کے لیے سٹرنگز استعمال نہیں کرنی چاہئیں۔

{ "enabled": "سچ", "count": "۱۰" }

{ "فعال": true, "تعداد": 10 }

JSON بولین، اعداد، اور اسٹرنگ میں فرق کرتا ہے—یقینی بنائیں کہ صحیح قسم استعمال کی گئی ہو۔

غیر ابتدائی کلیدیں

JSON آبجیکٹ کیز ہمیشہ سٹرنگز ہونی چاہئیں؛ آپ نمبر، بولین، یا دیگر اقسام کو کی کے طور پر استعمال نہیں کر سکتے۔

{ 123: "abc" }

{ "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 (اختیاری) ایک بولین ہونا چاہیے۔
• مندرجہ بالا تعریف شدہ خصوصیات کے علاوہ کوئی دیگر خصوصیات اجازت شدہ نہیں ہیں۔

حقیقی دنیا کی مثال: اسٹراپ 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)
  }
}

اس آلے کے بارے میں