JSON சோதனை கருவி

JSON செல்லுபடியாக்கல் என்பது என்ன?

JSON (ஜாவாஸ்கிரிப்ட் ஆப்ஜக்ட் நோட்டேஷன்) என்பது பரவலாக பயன்படுத்தப்படும், எளிமையான தரவு பரிமாற்ற வடிவமாகும், மனிதர்களுக்கு வாசிப்பதற்கும் இயந்திரங்களுக்கு எளிதாக புரிந்துகொள்ளவும் உருவாக்கப்பட்டுள்ளது. அதன் முதன்மை நோக்கம் ஆகும் கட்டமைக்கப்பட்ட தரவை—ஆப்ஜக்ட்கள், வரிசைகள், எழுத்துச்சட்டங்கள், எண்கள், பூலியன் மதிப்புகள் மற்றும் நள்ளிகள்—இதயம் சாரா முறையில் பிரதிபலிப்பது.

JSON சரிபார்ப்பு என்பது ஒரு JSON ஆவணம் சொற்பொருளிலும் கட்டமைப்பிலும் சரியாக இருக்குமா என்பதை நிரலாக்கவிதத்தில் உறுதிப்படுத்தும் செயல்முறை ஆகும். இதில் இரண்டு முக்கிய அம்சங்களைச் சரிபார்க்கிறது:

• வாக்கிய நிடான பரிசோதனை: அசல் உரை ECMA-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 போன்ற வடிவமைப்புகள் (உதாரணமாக, ஜாவாஸ்கிரிப்ட் பொருள் இலிட்டரல்கள்) குறியிடமில்லாத முக்கியச்சொற்களை அனுமதிக்கும், ஆனால் தரமான JSON அனுமதிக்காது.

தனிப்பட்ட சிற்றொட்டிகள்

JSON ஸ்டிரிங்கள் இரட்டை கோடிகளை மட்டுமே பயன்படுத்த வேண்டும்; ஒற்றை கோடிகள் அனுமதிக்கப்பட்ட இல்லை.

{ 'name': 'பாப்' }

{ "name": "பாப்" }

ஒரே மூடியெழுத்துக்களைப் பயன்படுத்து‌வது அனைத்து ஒத்திசைவு JSON நூலகங்களிலும் பாகுபடுத்துபவர் பிழைகளை ஏற்படுத்தும்.

முடிவில் கமா

ஒரு பொருள் அல்லது வரிசையின் கடைசி உருப்படியுக்கு பின் ஏதேனும் komma வரவேண்டாம்.

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

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

JavaScript-ல் trailing கமாஸ் வேலை செய்யலாம், ஆனால் கடுமையான JSON பார்சர்களில் அது வேலை செய்யாது.

தரவுகளை தவறான முறையில் வெளியேற்றல்

செய்திக் குறியீடுகள் மற்றும் சிறப்பு எழுத்துக்கள் சொல்லுக்குள் பயன்படுத்தும்போது பேகஸ்லாஷ் () மூலம்逃避 செய்ய வேண்டும்.

{ "quote": "டாம் "வணக்கம்" என்றார்" }

{ "quote": "டோம் \"ஹலோ\" என்றார்" }

மற்ற ஓட்டம் தொடர்கள் பின்துட்டை குறிக்கும் \\ ஆகும், புதிய வரிகளுக்காக \n ஆகும், மற்றும் குறியிடுகளுக்காக \t ஆகும்.

தவறு தரவு வகைகள்

எண்கள், பூலியன் மதிப்புகள் அல்லது null க்காக ஸ்ட்ரிங்குகளை பயன்படுத்தக் கூடாது.

{ "enabled": "செயல்படுத்தப்பட்டுள்ளது", "count": "10" }

{ "செயல்படுத்தப்பட்டது": true, "எண்ணிக்கை": 10 }

JSON புல்லியன்கள், எண்கள் மற்றும் சரங்களை வேறுபடுத்துகிறது—சரியான வகை பயன்படுத்தப்படுவதை உறுதிப்படுத்துங்கள்.

அமெரிக்கா வகை அல்லாத திறவுகள்

JSON பொருளின் விசைகள் எப்போதும் சரம் (strings) பொருத்தமானவை ஆக வேண்டும்; எண்கள், பூலியன்கள், அல்லது பிற வகைகளை விசைகளாக பயன்படுத்த முடியாது.

{ 123: "அப்சி" }

{ "123": "ஏபிசி" }

நகல் விசைகள்

JSON குறிப்பிட்டாலும், ஒரே பெயருடைய பல முக்கியங்கள் பொதுவாக பிழைகளுக்கு காரணமாகின்றன.

{ "name": "அலிஸ்", "name": "பாப்" }

பெரும்பாலான பார்சர்கள் இறுதியான மதிப்பை மட்டும் ("பாப்") வைத்திருப்பார்கள், முன்பு உள்ள மதிப்புகளை மௌனமாக இழக்க விடுகின்றனர்.

கருத்துக்களை பயன்படுத்துதல்

சாதாரண JSON கோப்புகளில் கருத்துகள் (comments) இட அனுமதிக்கப்பட்டிருக்கません, சில ஆசிரியர்கள் அவற்றை ஆதரித்தாலும்.

{
  // பயனர் தகவல்
  "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 குழாய்களில் பண்பட்ட களங்களை பயன்படுத்துங்கள்.
• குழு இடையியல் ஒருமை: முன்னணி, பின்தளம் மற்றும் மூன்றாம் தரப்பு 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)
  }
}

இந்த கருவி பற்றி