JSON ఫార్మాటర్

JSON ఫార్మాటింగ్ అంటే ఏంటి?

JSON ఫార్మాటింగ్ అనేది JSON డేటాను ఒక సెటైండ సంఖ్యలో, మానవ సరసమైన రూపంలో మార్చడం. దీని కోసం ఇన్‌డెంటేషన్, వైట్‌స్పేస్, లైన్ బ్రేక్స్ జోడించి, నిర్మాణం మరియు కంటెంట్ మార్చకుండా చేస్తారు. ఉపయుక్తంగా పరిశీలించడం, డీబగ్గింగ్, పంచుకోవడం, ఎడిట్ చేయడం సులభం చేస్తుంది, మరియు యంత్రాలతో కూడా అనుకూలంగా ఉంటుంది.

సాధారణంగా, JSON స్ట్రింగ్ విలువల వెలుపల వైట్‌స్పేస్ ని పట్టించుకోదు. కానీ చక్కగా ఫార్మాట్ చేయనప్పుడు లేదా ఒకే లైన్‌పై మినిఫై చేసినప్పుడు అందరికీ చదవడం లేదా మార్చడం కష్టంగా ఉంటుంది.

JSON ఫార్మాటింగ్ vs మినిఫై

• ఫార్మాటింగ్ స్పష్టత మరియు చదవడాన్ని పెంచడానికి వైట్‌స్పేస్, ఇన్‌డెంటేషన్, లైన్ బ్రేక్స్ ఇస్తుంది.
• మినిఫై చేయడం డేటా నిల్వ లేదా ట్రాన్స్ఫర్ సామర్థ్యాన్ని మెరుగుపర్చేందుకు అవసరంలేనైన అన్ని వైట్‌స్పేస్ ని తీసివేస్తుంది.
• ఒక శక్తివంతమైన 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 వంటి టూల్స్ ఫార్మాట్ చేసిన JSON తో మరింత అర్థవంతమైన డిఫ్స్ ఉత్పత్తి చేస్తాయి, మార్పుల ట్రాకింగ్ సులభం.
• నియమాలు: చాలా స్టైల్ గైడ్స్, ఆటోమేటెడ్ లిన్టర్లు (Prettier, ESLint, jq) అనుసంధానం మరియు స్పష్టత కోసం సరిగ్గా ఫార్మాట్ చేయాలని కోరుకుంటాయి.
• టూల్ అనుకూలత: కొంత APIలు, CLIలు, ఎడిటర్లు ఫార్మాట్ చేసిన ఇన్‌పుట్‌కు మెరుగైన మానవ ఇంటరాక్షన్ లేదా లాగ్ కోసం ఆశిస్తాయి.

JSON ఫార్మాటర్ ఎలా పనిచేస్తుంది?

1. పార్సింగ్: ఫార్మాటర్ ముందుగా మీ ఇన్‌పుట్‌ను కఠిన JSON పార్సర్ ఉపయోగించి విశ్లేషిస్తుంది. ఇది సింటాక్స్ సక్రమతను తనిఖీ చేస్తుంది – ఉద్దేశించిన కోట్లు, ట్రైలింగ్ కామాలు లేకపోవడం, అన్‌ఎస్కేప్డ్ అక్షరాల వంటి సమస్యలు గుర్తిస్తుంది.
2. ప్రిటి-ప్రింటింగ్: సరికొత్తగా పార్స్ చేయబడిన డేటాను, యూజర్ నిర్వచించిన ఇన్‌డెంటేషన్ (సాదారణంగా 2 లేదా 4 స్పేసులు) మరియు లైన్ బ్రేక్స్‌తో మరోసారి స్ట్రింగ్‌గా మార్చి, అందంగా ముద్రించబడినJSON తయారుచేస్తుంది.

ఇన్‌పుట్ చెల్లని JSON అయితే, ఫార్మాటర్ లోపం చూపుతుంది లేదా సమస్య స్థలం, స్వభావాన్ని వివరించే సహాయక సందేశాన్ని ఇస్తుంది.

ఫార్మాటింగ్ ఎంపికలు

• ఇన్‌డెంటేషన్: ప్రతి లెవల్‌కు స్పేసుల సంఖ్యను (గరిష్టం 8) సెట్ చేయండి.
• ఆబ్జెక్ట్ కీలు వర్ణమాల క్రమంలో వర్ధించండి
• స్పేసుల బదులుగా ఇన్‌డెంటేషన్ కోసం టాబ్స్ ఉపయోగించండి
• ASCII కాని అక్షరాలను యూనికోడ్‌గా ఎస్కేప్ చేయి
• ఫలితాన్ని మినిఫై చేయి (ఒకే లైన్, స్పేసులు లేకుండా)

ఫార్మాటింగ్ ద్వారా సాధించబడే సాధారణ సమస్యలు

• ఒకే లైన్/మినిఫై చేసిన JSON: APIల నుండి వచ్చిన డేటా లేదా లాగ్ ఫైళ్లు తరచూ బ్యాండ్విడ్త్ మరింత ఉండేందుకు మినిఫై చేస్తారు, దీని వల్ల మాన్యువల్ ఎడిటింగ్ కష్టం అవుతుంది. ఫార్మాటింగ్ ద్వారా చదవడం సులభం అవుతుంది.
• అసంపూర్ణ ఇన్‌డెంటేషన్: వివిధ మూలాల JSONలో మిశ్రమ టాబ్లు, స్పేసులు లేదా అనియమిత ఇన్‌డెంటేషన్ ఉండొచ్చు. ఫార్మాటింగ్ ఈ తేడాలను సుతారంగా నిలుపుతుంది, స్పష్టత పెంచుతుంది.
• పెద్ద/లోతైన నిర్మాణాలు: లోతైన నెస్టెడ్ అర్రేస్ లేదా ఆబ్జెక్టులు (కాన్ఫిగరేషన్ ఫైళ్లు లేదా సంక్లిష్ట API ప్రతిస్పందనలు) ఫార్మాట్ చేస్తే అవి ఎడిటర్‌లలో కలయిడైన దృష్టికోణంతో సులభంగా అధిగమించదగినవి అవుతాయి.

ప్రారంభ వాస్తవ ప్రపంచం: API ప్రతిస్పందన ఫార్మాటింగ్

మూడవ పక్ష APIల (AWS, Stripe, Google Cloud లాంటి)తో ఇంటిగ్రేటింగ్ చేస్తే, పర్యాయాలు వేగం కోసం సంకుచితంగా ఉంటాయి. JSON ఆ PTఅట్‌ను ఫార్మాట్ చేయడం లోపాల కోసం పరీక్షించడానికి, అనుకోని విలువలను డీబగ్గింగ్ చేయడానికి, లేదా పని స్నేహితులతో పంచుకోవడానికి సులభం.

{"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 ఫార్మాటింగ్ కొరకు కోడ్ ఉదాహరణలు

వివిధ ప్రోగ్రామింగ్ భాషల్లో 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)
}