JSON ફોર્મેટર

JSON ફોર્મેટિંગ શું છે?

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

નિયમાનુસાર JSON સ્ટ્રિંગ મૂલ્યોથી બહાર આવેલા વિથસ્પેસને અવગણે છે. જોકે, જરાબ આજ રીતે મિનિફાઇડ (એકલાઈનમાં) કે ખોટે ફોર્મેટ કરાયેલ 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) સ્પષ્ટતા અને સ્ટાન્ડર્ડાઈઝેશન માટે એકસરખું ફોર્મેટિંગ જાળવે છે.
• ટૂલ સુસંગતતા: કેટલીક APIs, CLI અને એડિટર્સ માનવ અને લોગિંગ માટે સરળ ઇન્ટરફેસ માટે ફોર્મેટ કરેલી ઇનપુટની અપેક્ષા રાખે છે.

JSON ફોર્મેટર કેવી રીતે કાર્ય કરે છે?

1. પાર્સિંગ: ફોર્મેટર પ્રથમ તમારા ઇનપુટ ટેક્સ્ટને કડક JSON પાર્સરથી પાર્સ કરવાનો પ્રયાસ કરે છે. આ તબક્કો સિyntax માન્યતા માટે ચકાસણી કરે છે—જેમ કે ખોટા કોટ્સ, ટ્રેલિંગ કોમાસ, અથવા અસંગત અક્ષરોની ત્રુટિઓ પકડે છે.
2. સુંદર પ્રિન્ટિંગ: માન્યપણે પાર્સ થયેલો ડેટા વપરાશકર્તા નિર્ધારિત ઇન્ડેન્ટેશન (સામાન્ય રીતે 2 કે 4 સ્પેસ) અને લાઇન બ્રેક સાથે ફરી સ્ટ્રિંગમાં રૂપાંતરિત થાય છે, જેને "pretty-printed" સંસ્કરણ કહે છે.

જો ઇનપુટ માન્ય JSON ન હોય, તો ફોર્મેટર ત્રુટિ બતાવે અથવા સમસ્યાનું સ્થાન અને સ્વરૂપ કરશે.

ફોર્મેટિંગ વિકલ્પો

• ઇન્ડેન્ટેશન: સ્તર માટે સ્પેસની સંખ્યા સુયોજિત કરો (અધિકત્તમ 8).
• ઓબ્જેક્ટ કી આક્ષરાનુક્રમે સૉર્ટ કરો
• ઇન્ડેન્ટેશન માટે સ્પેસની બદલે ટેબ્સ વાપરો
• ASCII સિવાયના અક્ષરોને Unicode રૂપે એસ્કેપ કરો
• આઉટપુટ મિનિફાઇ કરો (એક લીટી, કોઈ સ્પેસ નહીં)

ફોર્મેટિંગથી ઉકેલાયેલી સામાન્ય સમસ્યાઓ

• એકલાઈન/મિનિફાઇડ JSON: API અથવા લોગ ફાઇલો પાસેથી ડેટા મિનિફાઇડ હોય છે જેનું મેન્યુઅલ સંપાદન મુશ્કેલ હોય છે. ફોર્મેટિંગથી તે વાંચનક્ષમ બની જાય છે.
• અસંગત ઇન્ડેન્ટેશન: વિવિધ સ્ત્રોતમાંથી આવેલ JSON માં ટેબ્સ, સ્પેસ અને અસમાન ઇન્ડેન્ટેશન જોવા મળે છે. ફરીથી ફોર્મેટ કરવાથી આ તફાવત સંતુલિત અને સ્પષ્ટ બને છે.
• મોટા/ગૂંચવાયા સ્ટ્રક્ચર: ઊંડા નેસ્ટેડ એરે કે ઑબ્જેક્ટ (જેમ કે કન્ફિગ ફાઇલો કે જટિલ API રિસ્પોન્સ) ફોર્મેટિંગથી વધુ વ્યવસ્થિત બને છે અને આધાર આપતા એડિટર્સમાં કોલેપ્સ કરી શકાય તેવું જોવાય છે.

વાસ્તવિક ઉપયોગ: API રિસ્પોન્સ ફોર્મેટિંગ

ત્રીજા પક્ષના API સાથે ઈન્ટિગ્રેટ કરતી વખતે (AWS, 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. તમારું ઇનપુટ પ્રક્રિયા માટે "Format" પર ક્લિક કરો.
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)
}