JSON வடிவமைப்பாளர்

JSON வடிவமைப்பு란 무엇인가?

JSON வடிவமைப்பு என்பது JSON தரவை ஒரே மாதிரியான, மனிதர்க்குப் படிக்கத்தக்க வடிவில் மாற்றும் செயல்முறை, இதில் இடைவெளிகள், இடைநிலை மற்றும் வரி முறைகள் சேர்க்கப்படுகின்றன - இதனாலும் அதன் கட்டமைப்பு மற்றும் உள்ளடக்கம் மாற்றப்படாது. சரியான வடிவமைப்பு JSON ஐ ஆராய, பிழை திருத்த, பகிர, மற்றும் தொகுக்க எளிதாக்கும், மேலும் மெஷின்களுடனும் மென்பொருள் கருவிகளுடன் பொருத்தமானதாக இருக்கும்.

வரையறுக்கப்பட்டபடி, JSON எல்லா வெற்று இடங்களையும் string மதிப்புகள் வெளியில் புறக்கணிக்கும். எனினும், முறையாக வடிவமைக்கப்படாத (அல்லது சிறியதாக்கப்பட்ட) JSON — இடைவெளியிகளற்ற அல்லது ஒரே வரியிலிருந்து — மனிதர்களால் நம்பிக்கைபடுத்துபவராக வாசிக்க மற்றும் மாற்றுவது கடினமாக இருக்கும்.

JSON வடிவமைப்பு மற்றும் சிறியதாக்கலின் வித்தியாசம்

• வடிவமைப்பில் தெளிவு மற்றும் வாசகத்தன்மைக்காக இடைவெளிகள், இடைவெளி வைத்து வரிகள் சேர்க்கப்படுகின்றன.
• சிறியதாக்கலில் தேவையற்ற அனைத்து இடைவெளிகளும் அகற்றப்படுகின்றன, இதன் மூலம் சேமிப்பு அல்லது பரிமாற்றத்தில் மிகுந்த அதிரடியாக இருக்கும்.
• சிறந்த JSON வடிவமைப்பாளர் இந்த இரு முறைகளிலும் மாறும் வசதியை அளித்து, மனிதனுக்கான மற்றும் இயந்திரத்துக்கான வடிவங்களுக்கிடையில் மாற்ற எளிதாக்கிறது.

உதாரணம்: சிறியதாக்கப்பட்ட மற்றும் வடிவமைக்கப்பட்டது JSON

{"id":"3f4b2c","user":{"name":"Dana","is_active":true},"roles":["admin","editor"],"count":7}

{
  "id": "3f4b2c",
  "user": {
    "name": "Dana",
    "is_active": true
  },
  "roles": [
    "admin",
    "editor"
  ],
  "count": 7
}

JSONஐ எதற்கு வடிவமைக்க வேண்டும்?

• காணொளி: சரியான இடைவெளி மற்றும் வரிசை முறைகள் நசுக்கப்பட்ட பொருட்களை சுலபமாக ஆய்வு செய்ய, பிழைகளை கண்டுபிடிக்க மற்றும் சிக்கலான தரவு அமைப்புகளை எளிதில் புரிந்துகொள்ள உதவும்.
• பிழைத்திருத்தம்: தவறான அல்லது எதிர்பாராத தரவுகளை தெளிவாக பார்க்க மற்றும் விசைகள், மதிப்புகள் மற்றும் தொகுப்பு நிலைகளை குழப்பமின்றி கண்டுபிடிக்க உதவும்.
• ஒத்துழைப்பு: நன்கு வடிவமைக்கப்பட்ட JSON ஐ குறியீடு பரிசீலனைகள், ஆவணங்கள் அல்லது பகிரப்பட்ட கோப்புகளில் மேலாண்மை செய்யவும், விவாதிக்கவும், திருத்தவும் எளிதாக்கும்.
• பதிவு மேலாண்மை: Git மற்றும் பிற VCS கருவிகள் வடிவமைக்கப்பட்ட JSON உடன் பொருந்தக்கூடிய வேறுபாடுகளை உருவாக்கி, மாற்றங்களை தெளிவாக கண்காணிக்க உகந்தவை.
• கானூனீகப்படுத்தல்: பல நியமங்கள் மற்றும் தானாக இயங்கும் நிலைநடைகளும் (Prettier, ESLint அல்லது jq போன்றவை) தெளிவும் ஒருங்கிணைக்கும் விதத்தில் வடிவமைப்பை கட்டாயப்படுத்துகின்றன.
• கருவி பொருத்தத்தன்மை: சில APIகள், CLIகள் மற்றும் திருத்திகள் மனித நாட்டுக்கு உட்பட்ட அல்லது பதிவு செய்யும் படி வடிவமைக்கப்பட்ட உள்ளீட்டை எதிர்பார்க்கின்றன.

JSON வடிவமைப்பாளர் எப்படி செயல்படுகிறது?

1. பரிசோதனை: வடிவமைப்பாளர் முதலில் உங்கள் உள்ளீடு உரையை கடுமையான JSON பார்சரைப் பயன்படுத்தி பகுப்பாய்வு செய்கிறது. இது குறியிடல் செல்லுபடியாக்பவை என்பதை சரிபார்க்கும் — குறிப்பு மாறினால், தவறான குறியீடுகள், கடைசிப் பிறப்புகள் அல்லது ஓவருக்கோடுகள் போன்ற பிழைகள் பரிசோதிக்கப்படும்.
2. அழகுபடுத்தல் அச்சிடல்: செல்லுபடியானதும், அந்த தரவு பயனர் வரையறுக்கும் இடைவெளி மற்றும் வரிசை முறைகளுடன் மீண்டும் உரையாக மாற்றி ஒரு "அழகுபடுத்தப்பட்ட" பதிப்பை உருவாக்கும்.

உள்ளீடு செல்லுபடியாகாத JSON என்றால், வடிவமைப்பாளர் பிழை அனுப்பும் அல்லது பிழை உள்ள இடமும் தன்மையும் குறிப்பிட்ட ஒரு உதவிகரமான செய்தியைக் கொடுக்கும்.

வடிவமைப்பு விருப்பங்கள்

• இடைவேளை அளவு: ஒரு படியனுக்கு இடைவெளி எண்ணிக்கை (அதிகபட்சம் 8).
• விஷயங்களின் விசைகளை குறுக்கெழுத்துக்களில் வரிசைப்படுத்தவும்
• இடைவெளிக்கு பதிலாக குறிச்சொற்கள் பயன்படுத்தவும்
• ASCII-வுக்கு அப்பாற்பட்ட எழுத்துக்களை Unicode ஆக மாற்றவும்
• விளைவுகளை சிறியதாக்க (ஒரே வரி, இடைவெளிகள் இல்லாமல்)

வடிவமைப்பால் தீர்க்கப்படும் பொதுவான பிரச்சனைகள்

• ஒரே வரி/சிறியதாக்கப்பட்ட JSON: APIகளிலிருந்து அல்லது பதிவு கோப்புகளிலிருந்து வந்து, அடர்த்தி காரணமாக சிறியதாக்கப்பட்ட JSON கைமுறை தொகுக்க கடினமாக இருக்கும். வடிவமைப்பு வாசகத்தன்மை மீட்டெடுக்கிறது.
• தவறான இடைவேளைகள்: பல இடங்களில் இருந்து ஒட்டிய JSONக்குள் கலந்து நிரப்பப்பட்ட குறிச்சொற்கள், இடைவெளிகள் அல்லது இடைவெளை ஆழங்கள் இருக்கலாம். மறுவடிவமைப்பு இதை ஒரே மாதிரியாக்கி தெளிவும் ஒருங்கிணையும் தன்மையும் தருகிறது.
• பெரிய/குழந்தை அமைப்புகள்: ஆழமான தொகுதிகள் (உதாரணமாக கட்டமைப்பு கோப்புகள் அல்லது சிக்கலான API பதில்கள்) வடிவமைக்கபட்டால் எளிதில் ஆராயவும், பின்தொடரவும், உடைநிலை திருத்தங்களுடன் காண்வதற்கு பயனுள்ளது.

உலகச் சோதனை நிலை: API பதில்கள் வடிவமைப்பு

மூன்றாம் தரப்பு APIகளை(Microsoft, Stripe, Google Cloud போன்றவை) இணைக்கும் பொழுது, பதில்கள் வேகத்துக்காக சுருக்கப்பட்டிருக்கும். JSON விளைவுகளை வடிவமைத்து சரிபார்க்க, தவறான மதிப்புகளை காண, அல்லது குழுவுடன் பகிர எளிதாக்கலாம்.

{"amount":2500,"currency":"usd","status":"succeeded","charges":[{"id":"ch_1Gq","amount":2500}]}

{
  "amount": 2500,
  "currency": "usd",
  "status": "succeeded",
  "charges": [
    {
      "id": "ch_1Gq",
      "amount": 2500
    }
  ]
}

இந்த கருவியுடன் JSON ஐ எப்படி வடிவமைப்பது

1. உங்கள் மூல, சிறியதாக்கப்பட்ட அல்லது முறையாக இல்லாத JSON ஐ உள்ளீட்டுப் பகுதியில் ஒட்டி அல்லது ஏற்றவும்.
2. வடிவமைப்பு விருப்பங்களை (இடைவேளை அளவு, விசைகள் வரிசைப்படுத்தல், முதலியன) தேர்ந்தெடுக்கவும்.
3. உள்ளீடு செயலாக்க "வடிவமைக்க" அழுத்தவும்.
4. சுத்தமான, வாசகத்தக்க விளைவுகளைப் பார் அல்லது நகலெடு. பிழைகள் இருந்தால், பிழை சுயவிவரங்கள் உதவி செய்ய காட்டு.

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

JSON வடிவமைப்பிற்கான குறியீட்டு எடுத்துக்காட்டுகள்

விவிதமான நிரலாக்க மொழிகளில் JSON ஐ எவ்வாறு வடிவமைக்கலாம் என்பதைப் பாருங்கள். இந்த எடுத்துக்காட்டுகள் அடிப்படை வடிவமைப்பு நுட்பங்களை விளக்குகின்றன.

const ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
const pretty = JSON.stringify(JSON.parse(ugly), null, 2);
console.log(pretty);

import json
ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}'
pretty = json.dumps(json.loads(ugly), indent=2)
print(pretty)

package main
import (
  "encoding/json"
  "fmt"
)
func main() {
  ugly := []byte(`{"name":"Alice","age":30,"roles":["admin","user"]}`)
  var obj interface{}
  json.Unmarshal(ugly, &obj)
  pretty, _ := json.MarshalIndent(obj, "", "  ")
  fmt.Println(string(pretty))
}

import com.fasterxml.jackson.databind.ObjectMapper;
public class Main {
  public static void main(String[] args) throws Exception {
    String ugly = "{"name":"Alice","age":30,"roles":["admin","user"]}";
    ObjectMapper mapper = new ObjectMapper();
    Object obj = mapper.readValue(ugly, Object.class);
    String pretty = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
    System.out.println(pretty);
  }
}

using System;
using Newtonsoft.Json;
class Program {
  static void Main() {
    var ugly = "{"name":"Alice","age":30,"roles":["admin","user"]}";
    var parsed = JsonConvert.DeserializeObject(ugly);
    var pretty = JsonConvert.SerializeObject(parsed, Formatting.Indented);
    Console.WriteLine(pretty);
  }
}

<?php
$ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
$obj = json_decode($ugly);
echo json_encode($obj, JSON_PRETTY_PRINT);

require 'json'
ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}'
pretty = JSON.pretty_generate(JSON.parse(ugly))
puts pretty

echo '{"name":"Alice","age":30,"roles":["admin","user"]}' | jq .

fn main() {
  let ugly = r#"{"name":"Alice","age":30,"roles":["admin","user"]}"#;
  let value: serde_json::Value = serde_json::from_str(ugly).unwrap();
  let pretty = serde_json::to_string_pretty(&value).unwrap();
  println!("{}", pretty);
}

import com.fasterxml.jackson.databind.ObjectMapper
fun main() {
  val ugly = "{"name":"Alice","age":30,"roles":["admin","user"]}"
  val mapper = ObjectMapper()
  val obj = mapper.readValue(ugly, Any::class.java)
  val pretty = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj)
  println(pretty)
}

import Foundation
let ugly = "{\"name\":\"Alice\",\"age\":30,\"roles\":[\"admin\",\"user\"]}"
if let data = ugly.data(using: .utf8),
   let obj = try? JSONSerialization.jsonObject(with: data),
   let pretty = try? JSONSerialization.data(withJSONObject: obj, options: .prettyPrinted),
   let prettyString = String(data: pretty, encoding: .utf8) {
    print(prettyString)
}

const ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
const pretty = JSON.stringify(JSON.parse(ugly), null, 2);
console.log(pretty);

SELECT jsonb_pretty('{"name":"Alice","age":30,"roles":["admin","user"]}'::jsonb);

SELECT JSON_PRETTY('{"name":"Alice","age":30,"roles":["admin","user"]}');

$ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}'
$obj = $ugly | ConvertFrom-Json
$pretty = $obj | ConvertTo-Json -Depth 10
Write-Output $pretty

use JSON;
my $ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
my $obj = decode_json($ugly);
print to_json($obj, { pretty => 1 });

import 'dart:convert';
void main() {
  const ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
  final obj = jsonDecode(ugly);
  final pretty = JsonEncoder.withIndent('  ').convert(obj);
  print(pretty);
}

ugly = ~s({"name":"Alice","age":30,"roles":["admin","user"]})
{:ok, obj} = Jason.decode(ugly)
pretty = Jason.encode!(obj, pretty: true)
IO.puts(pretty)

import play.api.libs.json._
object Main extends App {
  val ugly = """{"name":"Alice","age":30,"roles":["admin","user"]}"""
  val jsValue = Json.parse(ugly)
  val pretty = Json.prettyPrint(jsValue)
  println(pretty)
}