JSON स्वरूपित करणारे

या साध्या साधनाने तुमचा JSON स्वरूपित आणि सुंदर करा

कच्चा JSON इनपुट*

स्वरूपित JSON आउटपुट

स्वरूपित JSON येथे दिसेल...

JSON Formatter

परिचय

JSON (JavaScript ऑब्जेक्ट नोटेशन) हा एक हलका डेटा इंटरचेंज फॉरमॅट आहे जो वेब अनुप्रयोगांमध्ये डेटा एक्सचेंजसाठी मानक बनला आहे. त्याच्या साधेपणामुळे, JSON डेटा मिनिफाइड किंवा योग्य फॉरमॅटिंग नसल्यास वाचायला कठीण होऊ शकतो. हे टूल तुम्हाला कच्च्या, अनफॉरमॅटेड JSON स्ट्रिंग्सला चांगल्या प्रकारे संरचित, इंडेंटेड फॉरमॅटमध्ये रूपांतरित करण्यात मदत करते, जे वाचायला आणि विश्लेषण करायला खूप सोपे आहे.

JSON फॉरमॅटिंग (जे "प्रीटी प्रिंटिंग" म्हणूनही ओळखले जाते) प्रत्येक स्तरावर योग्य इंडेंटेशन, ओळीत ब्रेक आणि स्पेसिंग जोडते जे JSON डेटाच्या संरचनेला दृश्यात्मक रूपात स्पष्ट करते. हे विशेषतः जटिल नेस्टेड ऑब्जेक्ट्स किंवा मोठ्या डेटासेट्ससाठी मूल्यवान आहे जिथे घटकांमधील संबंध अन्यथा समजून घेणे कठीण असू शकते.

आमचे JSON फॉरमॅटर टूल तुमच्या JSON डेटाला योग्य इंडेंटेशन आणि संरचनेसह सुंदर बनवण्यासाठी एक साधी इंटरफेस प्रदान करते, जे मानवी वाचनासाठी अधिक वाचनीय आहे, तर मशीनसाठी त्याची वैधता राखते.

JSON सिंटॅक्स आणि संरचना

JSON दोन प्राथमिक संरचनांवर आधारित आहे:

ऑब्जेक्ट्स: वक्र ब्रेसेस {} मध्ये बंद केलेल्या नाव/मूल्य जोड्यांचे संग्रह. प्रत्येक नावाच्या मागे एक कॉलन : असतो आणि जोड्या कॉमा , द्वारे विभक्त केल्या जातात.

   {"name": "John", "age": 30, "city": "New York"}

अरे: चौकोनी ब्रेकेट्स [] मध्ये बंद केलेल्या मूल्यांच्या ऑर्डर केलेल्या यादी. मूल्ये कॉमा , द्वारे विभक्त केल्या जातात.

   ["apple", "banana", "cherry"]

JSON मूल्ये असू शकतात:

स्ट्रिंग्स (डबल कोट्समध्ये): "Hello World"
नंबर: 42 किंवा 3.14159
बूलियन्स: true किंवा false
नल: null
ऑब्जेक्ट्स: {"key": "value"}
अरे: [1, 2, 3]

योग्य JSON या सिंटॅक्स नियमांचे पालन करणे आवश्यक आहे:

नावे डबल कोट्समध्ये असली पाहिजे
मूल्ये वैध JSON डेटा प्रकारांपैकी एक असली पाहिजे
ट्रेलिंग कॉमा असू नये
टिप्पण्या परवानगी नाहीत
फंक्शन्स किंवा पद्धती असू नयेत

सामान्य सिंटॅक्स त्रुट्या यामध्ये समाविष्ट आहेत:

गहाळ किंवा विसंगत ब्रेकेट्स/ब्रेसेस
प्रॉपर्टी नांवांच्या गहाळ कोट्स
प्रॉपर्टी नांवांसाठी एकल कोट्सचा वापर
ट्रेलिंग कॉमा समाविष्ट करणे
मूल्य म्हणून अनिर्धारित वापरणे

JSON फॉरमॅटिंग कसे कार्य करते

JSON फॉरमॅटिंग संकुचित, मिनिफाइड JSON ला अधिक वाचनीय स्वरूपात रूपांतरित करते:

पार्सिंग: JSON स्ट्रिंग प्रथम वैध आहे का ते सुनिश्चित करण्यासाठी पार्स केले जाते आणि डेटा संरचनेचे इन-मेमरी प्रतिनिधित्व तयार केले जाते.
इंडेंटेशन: ऑब्जेक्ट्स आणि अरेच्या प्रत्येक नेस्टेड स्तरावर इंडेंटेशन (सामान्यतः 2 किंवा 4 स्पेस) जोडले जाते जे दृश्यात्मकपणे पदानुक्रम दर्शवते.
ओळ ब्रेक: प्रत्येक प्रॉपर्टी किंवा अरे घटकानंतर नवीन ओळी जोडल्या जातात जे वाचनासाठी सुधारित करते.
स्पेसिंग: कॉलन आणि कॉमाच्या आजूबाजूला सुसंगत स्पेसिंग जोडले जाते.

उदाहरणार्थ, हा मिनिफाइड JSON:

{"name":"John Doe","age":30,"address":{"street":"123 Main St","city":"Anytown","state":"CA"},"hobbies":["reading","hiking","photography"]}

हा फॉरमॅट केलेला JSON बनतो:

{
  "name": "John Doe",
  "age": 30,
  "address": {
    "street": "123 Main St",
    "city": "Anytown",
    "state": "CA"
  },
  "hobbies": [
    "reading",
    "hiking",
    "photography"
  ]
}

आमचे फॉरमॅटर प्रत्येक स्तरासाठी 2 स्पेसच्या मानक इंडेंटेशनचा वापर करतो, जो विकास समुदायात सामान्य परंपरा आहे आणि संकुचन आणि वाचनक्षमता यामध्ये चांगला संतुलन प्रदान करतो.

JSON वैधता

JSON फॉरमॅटिंगचा एक महत्त्वाचा पैलू म्हणजे वैधता. JSON फॉरमॅट करण्यापूर्वी, ते JSON विशिष्टतेनुसार सिंटॅक्सदृष्ट्या वैध असावे लागते. सामान्य वैधता त्रुट्या यामध्ये समाविष्ट आहेत:

सिंटॅक्स त्रुट्या:
- गहाळ प्रॉपर्टी नावे
- गहाळ किंवा अतिरिक्त कॉमा
- चुकीच्या नेस्टेड संरचना
- गहाळ स्ट्रिंग्स, ऑब्जेक्ट्स, किंवा अरे
डेटा प्रकार त्रुट्या:
- undefined किंवा NaN सारख्या JavaScript-विशिष्ट मूल्यांचा वापर
- फंक्शन्स किंवा पद्धती समाविष्ट करणे
- स्ट्रिंग्ससाठी एकल कोट्सचा वापर

जेव्हा तुम्हाला अवैध JSON मिळतो, तेव्हा त्रुटी संदेश समस्येची ओळख करण्यात मदत करू शकतात. बहुतेक JSON पार्सर्स पार्सिंग अयशस्वी झालेल्या स्थानाचे निर्देशांक दर्शवतात, जे समस्येचे स्थान ओळखण्यात मदत करू शकते. आमचे टूल स्पष्ट त्रुटी संदेश प्रदान करते जे तुम्हाला तुमच्या JSON डेटामध्ये समस्या ओळखण्यात आणि दुरुस्त करण्यात मदत करते.

वापराचे प्रकरणे

JSON फॉरमॅटिंग अनेक परिस्थितींमध्ये मूल्यवान आहे:

API विकास आणि चाचणी

RESTful APIs सह काम करताना, फॉरमॅट केलेला JSON वाचायला सोपा बनवतो:

प्रतिसाद पेल्यातील तपशील तपासणे
विनंती शरीराचे डिबगिंग करणे
API उदाहरणे दस्तऐवजीकरण करणे
डेटा संरचना अपेक्षांशी जुळतात का ते सत्यापित करणे

कॉन्फिगरेशन व्यवस्थापन

अनेक आधुनिक अनुप्रयोग JSON चा वापर कॉन्फिगरेशनसाठी करतात:

अनुप्रयोग सेटिंग्ज फाइल्स
वातावरण कॉन्फिगरेशन्स
बिल्ड आणि तैनाती विशिष्टता
इन्फ्रास्ट्रक्चर as Code टेम्पलेट्स (उदा., AWS CloudFormation, Terraform)

डेटा विश्लेषण आणि दृश्यता

फॉरमॅट केलेला JSON उपयुक्त आहे जेव्हा:

डेटासेट्सचा अभ्यास करणे
दृश्यता साठी डेटा तयार करणे
डेटा स्कीमा समजून घेणे
संरचित डेटामध्ये नमुने ओळखणे

डिबगिंग आणि समस्या निवारण

योग्यपणे फॉरमॅट केलेला JSON आवश्यक आहे जेव्हा:

वेब अनुप्रयोगांचे डिबगिंग करणे
localStorage किंवा sessionStorage तपासणे
नेटवर्क प्रतिसादांचे विश्लेषण करणे
डेटा समाकलन समस्यांचे निवारण करणे

शैक्षणिक उद्देश

स्पष्ट JSON फॉरमॅटिंग शैक्षणिक उद्देशांसाठी मूल्यवान आहे:

डेटा संरचना शिकवणे
नेस्टेड संबंध स्पष्ट करणे
API संकल्पना स्पष्ट करणे
डेटा मॉडेलिंग तत्त्वे दर्शविणे

पर्याय

आमचे वेब-आधारित JSON फॉरमॅटर जलद फॉरमॅटिंग कार्यांसाठी सोयीस्कर आहे, परंतु विविध परिस्थितींसाठी अनेक पर्याय उपलब्ध आहेत:

ब्राउझर डेव्हलपर टूल्स

आधुनिक ब्राउझर्स JSON फॉरमॅटिंग क्षमतांचा समावेश करतात:

Chrome आणि Edge DevTools नेटवर्क टॅबमध्ये JSON प्रतिसादांना स्वयंचलितपणे फॉरमॅट करतात
Firefox चा JSON दर्शक इंटरएक्टिव्ह ट्री दृश्य प्रदान करतो
JSONView सारख्या ब्राउझर विस्तारांमुळे ब्राउझरमध्ये थेट JSON फॉरमॅट केला जाऊ शकतो

कोड संपादक आणि IDEs

अधिकतर विकास वातावरण JSON फॉरमॅटिंग ऑफर करतात:

Visual Studio Code मध्ये अंतर्गत JSON फॉरमॅटिंग आहे (Alt+Shift+F)
JetBrains IDEs (WebStorm, IntelliJ) मध्ये शक्तिशाली JSON टूल्स समाविष्ट आहेत
Sublime Text आणि Atom प्लगइन्सद्वारे JSON फॉरमॅटिंगला समर्थन देतात

कमांड लाइन टूल्स

टर्मिनल वापरकर्ते किंवा स्वयंचलनासाठी:

jq एक शक्तिशाली कमांड-लाइन JSON प्रोसेसर आहे
json_pp अनेक युनिक्स सिस्टमवर पूर्व-स्थापित आहे
python -m json.tool Python चा वापर करून जलद फॉरमॅटिंग प्रदान करते

प्रोग्रामेटिक दृष्टिकोन

अनुप्रयोगांमध्ये JSON फॉरमॅट करताना:

// JavaScript
const formatted = JSON.stringify(jsonObject, null, 2);

# Python
import json
formatted = json.dumps(json_object, indent=2)

// Java with Gson
Gson gson = new GsonBuilder().setPrettyPrinting().create();
String formatted = gson.toJson(jsonObject);

# Ruby
require 'json'
formatted = JSON.pretty_generate(json_object)

// PHP
$formatted = json_encode($jsonObject, JSON_PRETTY_PRINT);

इतिहास

JSON चा निर्माण डग्लस क्रॉकफोर्डने 2000 च्या दशकाच्या सुरुवातीस XML च्या हलक्या पर्याय म्हणून केला. हा फॉरमॅट JavaScript ऑब्जेक्ट लिटरल सिंटॅक्सवर आधारित आहे, परंतु भाषेच्या दृष्टिकोनातून स्वतंत्र बनवला आहे. 2006 मध्ये, JSON औपचारिकपणे RFC 4627 मध्ये निर्दिष्ट केले गेले, आणि त्याच्या साधेपणामुळे आणि JavaScript सह सुसंगततेमुळे त्याला जलद लोकप्रियता मिळाली.

JSON पूर्वी, XML डेटा इंटरचेंजसाठी प्रमुख फॉरमॅट होता, परंतु त्याची विस्तृतता आणि जटिलता अनेक अनुप्रयोगांसाठी त्रासदायक बनली. JSON ने एक अधिक संक्षिप्त सिंटॅक्स ऑफर केला जो मानव आणि मशीन दोन्हींसाठी वाचायला आणि लिहायला सोपा होता. याने JavaScript च्या ऑब्जेक्ट मॉडेलसह परिपूर्णपणे जुळले, ज्यामुळे ते वेब अनुप्रयोगांसाठी नैसर्गिक निवड बनले.

JSON चा स्वीकार 2000 च्या दशकाच्या मध्यभागी AJAX आणि RESTful APIs च्या उदयासह गती घेतला. 2010 च्या दशकाच्या सुरुवातीस, हे वेब APIs, कॉन्फिगरेशन फाइल्स, आणि MongoDB आणि CouchDB सारख्या NoSQL डेटाबेसमध्ये डेटा संग्रहित करण्यासाठी मानक बनले.

आज, JSON जवळजवळ प्रत्येक प्रोग्रामिंग भाषेद्वारे समर्थित आहे आणि वेबवर असंख्य अनुप्रयोगांमध्ये वापरला जातो. त्याची साधेपणा, लवचिकता, आणि सार्वभौम समर्थनामुळे तो आधुनिक संगणकातील सर्वात महत्त्वाच्या डेटा फॉरमॅट्सपैकी एक बनला आहे.

कोड उदाहरणे

येथे विविध प्रोग्रामिंग भाषांमध्ये JSON फॉरमॅट करण्याचे उदाहरणे आहेत:

// JavaScript JSON फॉरमॅटिंग
function formatJSON(jsonString) {
  try {
    const parsedData = JSON.parse(jsonString);
    return JSON.stringify(parsedData, null, 2);
  } catch (error) {
    return `Error: ${error.message}`;
  }
}

// उदाहरण वापर
const rawJSON = '{"name":"John","age":30,"city":"New York"}';
console.log(formatJSON(rawJSON));

# Python JSON फॉरमॅटिंग
import json

def format_json(json_string):
    try:
        parsed_data = json.loads(json_string)
        return json.dumps(parsed_data, indent=2)
    except json.JSONDecodeError as e:
        return f"Error: {str(e)}"

# उदाहरण वापर
raw_json = '{"name":"John","age":30,"city":"New York"}'
print(format_json(raw_json))

// Java JSON फॉरमॅटिंग with Gson
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonSyntaxException;

public class JSONFormatter {
    public static String formatJSON(String jsonString) {
        try {
            Gson gson = new GsonBuilder().setPrettyPrinting().create();
            Object parsedJson = gson.fromJson(jsonString, Object.class);
            return gson.toJson(parsedJson);
        } catch (JsonSyntaxException e) {
            return "Error: " + e.getMessage();
        }
    }
    
    public static void main(String[] args) {
        String rawJSON = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}";
        System.out.println(formatJSON(rawJSON));
    }
}

// PHP JSON फॉरमॅटिंग
function formatJSON($jsonString) {
    $result = json_decode($jsonString);
    if (json_last_error() !== JSON_ERROR_NONE) {
        return "Error: " . json_last_error_msg();
    }
    return json_encode($result, JSON_PRETTY_PRINT);
}

// उदाहरण वापर
$rawJSON = '{"name":"John","age":30,"city":"New York"}';
echo formatJSON($rawJSON);

# Ruby JSON फॉरमॅटिंग
require 'json'

def format_json(json_string)
  begin
    parsed_data = JSON.parse(json_string)
    return JSON.pretty_generate(parsed_data)
  rescue JSON::ParserError => e
    return "Error: #{e.message}"
  end
end

# उदाहरण वापर
raw_json = '{"name":"John","age":30,"city":"New York"}'
puts format_json(raw_json)

// C# JSON फॉरमॅटिंग with Newtonsoft.Json
using Newtonsoft.Json;
using System;

class JSONFormatter
{
    public static string FormatJSON(string jsonString)
    {
        try
        {
            object parsedJson = JsonConvert.DeserializeObject(jsonString);
            return JsonConvert.SerializeObject(parsedJson, Formatting.Indented);
        }
        catch (JsonException e)
        {
            return $"Error: {e.Message}";
        }
    }
    
    static void Main()
    {
        string rawJSON = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}";
        Console.WriteLine(FormatJSON(rawJSON));
    }
}

// Go JSON फॉरमॅटिंग
package main

import (
    "encoding/json"
    "fmt"
)

func formatJSON(jsonString string) string {
    var parsedData interface{}
    err := json.Unmarshal([]byte(jsonString), &parsedData)
    if err != nil {
        return fmt.Sprintf("Error: %s", err.Error())
    }
    
    formattedBytes, err := json.MarshalIndent(parsedData, "", "  ")
    if err != nil {
        return fmt.Sprintf("Error: %s", err.Error())
    }
    
    return string(formattedBytes)
}

func main() {
    rawJSON := `{"name":"John","age":30,"city":"New York"}`
    fmt.Println(formatJSON(rawJSON))
}

कडवट प्रकरणे आणि विचार

JSON फॉरमॅटिंगसह काम करताना, या संभाव्य आव्हानांबद्दल जागरूक रहा:

मोठे JSON फाइल्स

खूप मोठ्या JSON फाइल्स (काही मेगाबाइट्स किंवा अधिक) ब्राउझर-आधारित फॉरमॅटर्समध्ये कार्यक्षमता समस्या निर्माण करू शकतात. अशा प्रकरणांमध्ये:

jq सारख्या कमांड-लाइन टूल्सचा विचार करा
JSON छोटे तुकडे करा
संपूर्ण फाइल मेमरीमध्ये लोड न करता प्रक्रिया करण्यासाठी स्ट्रीमिंग पार्सर्सचा वापर करा

खूप नेस्टेड संरचना

अत्यंत नेस्टेड JSON (10-20 स्तरांपेक्षा अधिक) फॉरमॅट केलेले असले तरी देखील नेव्हिगेट करणे कठीण होऊ शकते. अशा प्रकरणांमध्ये:

शक्य असल्यास संरचना समतल करण्याचा विचार करा
वक्र JSON दर्शकांचा वापर करा
JSON च्या विशिष्ट भागांसह काम करा

विशेष वर्ण आणि युनिकोड

JSON युनिकोडला समर्थन देतो, परंतु काही फॉरमॅटर्स काही वर्णांसह समस्या निर्माण करू शकतात:

तुमचा फॉरमॅटर इमोजी आणि इतर युनिकोड वर्ण योग्यरित्या हाताळतो याची खात्री करा
नियंत्रण वर्णे आणि पळवाट अनुक्रमांसह सावध रहा
फॉरमॅट केलेला आउटपुट सर्व मूळ वर्ण जतन करतो याची पुष्टी करा

संख्यात्मक अचूकता

JSON संख्यांसाठी अचूकता निर्दिष्ट करत नाही, ज्यामुळे खूप मोठ्या पूर्णांक किंवा फ्लोटिंग-पॉइंट मूल्यांसह समस्या निर्माण होऊ शकतात:

53 बिट्सच्या पलीकडे पूर्णांकांसाठी काही JavaScript अंमलात अचूकता गमावली जाऊ शकते याची माहिती ठेवा
अचूक संख्यात्मक मूल्यांसाठी स्ट्रिंग प्रतिनिधित्व वापरण्याचा विचार करा
तुमच्या अनुप्रयोगाला उच्च अचूकतेची आवश्यकता असल्यास अत्यधिक मूल्यांसह चाचणी करा

रिक्त ऑब्जेक्ट्स आणि अरे

वैध JSON मध्ये रिक्त ऑब्जेक्ट {} आणि अरे [] समाविष्ट आहेत, जे योग्यरित्या फॉरमॅट केले पाहिजेत:

रिक्त ऑब्जेक्ट {} म्हणून दिसले पाहिजे
रिक्त अरे [] म्हणून दिसले पाहिजे
नेस्टेड रिक्त संरचना योग्य इंडेंटेशन राखली पाहिजे

संदर्भ

JSON.org - अधिकृत JSON विशिष्टता वेबसाइट
RFC 8259 - JSON डेटा इंटरचेंज फॉरमॅट
MDN वेब डॉक्स: JSON - JavaScript मध्ये JSON वर व्यापक दस्तऐवजीकरण
JSON Lint - एक लोकप्रिय ऑनलाइन JSON वैधता साधन
jq - एक हलका आणि लवचिक कमांड-लाइन JSON प्रोसेसर