JSON ഫോർമാറ്റർ

JSON ഫോർമാറ്റിംഗ് എന്താണ്?

JSON ഡാറ്റയെ ഏകരൂപവും മനുഷ്യൻ വായിക്കാൻ എളുപ്പവുമായ രൂപത്തിലാക്കുന്നതിനുള്ള പ്രക്രിയയാണ് JSON ഫോർമാറ്റിംഗ്. ഇൻഡെന്റേഷൻ, വെളിപ്പെടുത്തൽ, വരിവിരൽ എന്നിവ ചേർത്ത് ഈ രൂപാന്തരത്തിന് വഴിയൊരുക്കുന്നു—ഘടനയും ഉള്ളടക്കവും മാറ്റമില്ലാതെ. ശരിയായ ഫോർമാറ്റിംഗ് JSON പരിശോധിക്കുക, പിഴവുകൾ കണ്ടെത്തുക, പങ്കുവെക്കുക, എഡിറ്റ് ചെയ്യുക എന്നിവക്ക് എളുപ്പമാക്കും, അതേസമയം യന്ത്രങ്ങളുടെയും സോഫ്റ്റ്‌വെയർ ഉപകരണങ്ങളുടെയും അനുയോജ്യത ഉറപ്പ് വരുത്തും.

സംവൃതഭാഗങ്ങളായ സ്ട്രിംഗ് മൂല്യങ്ങളെ ഒഴിച്ചുള്ള JSON സാദാരണമായി വെളിപ്പെടുത്തൽ ഇടങ്ങളിൽ ശ്രദ്ധിക്കാറില്ല. എന്നാൽ, മോശം ഫോർമാറ്റ് ചെയ്ത അല്ലെങ്കിൽ മിനിമൈസ് ചെയ്ത JSON – ഇൻഡെന്റേഷൻ இல்லാത്തത് അല്ലെങ്കിൽ ഒറ്റ വരിയിലായി സംകുചിതമായത് – മനുഷ്യരെക്കുറിച്ച് വായിക്കാനും സുദ്വേഷം മാറ്റാനും വലിçന അനുസരണമാവാം.

JSON ഫോർമാറ്റിംഗിനും മിനിമൈസിംഗിനും ഇടയിലെ വ്യത്യാസം

• ഫോർമാറ്റിംഗ് വെളിപ്പെടുത്തും ഇന്ത്യൻഡന്റേഷൻ മൂല്യങ്ങളും വരിവിരലുകളും ചേർത്തു, വായനക്കും വ്യക്തതക്കും സഹായിക്കുന്നു.
• മിനിമൈന് ഔദ്യോഗികമായ എല്ലാ അനാവശ്യ സ്പേസുകൾ നീക്കിയതിനാൽ സംഭരണം അല്ലെങ്കിൽ കൈമാറ്റത്തിനായി ഏറ്റവും സംകുചിതവുമാകും.
• ശക്തമായ JSON ഫോർമാറ്റർ ഈ മോഡുകൾ തമ്മിൽ മാറാനും, മനുഷ്യനു സൗകര്യമുള്ളതും യന്ത്രത്തിനായി മെച്ചപ്പെടുത്തിയതുമായ പതിപ്പുകൾ അതായത് ആവശ്യാനുസരണം എളുപ്പം തിരഞ്ഞെടുക്കാനും കഴിയും.

ഉദാഹരണം: മിനിമൈസ് ചെയ്ത JSON vs ഫോംമാറ്റ് ചെയ്ത 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 പോലുള്ള സ്റ്റൈൽ ഗൈഡുകളും ഓട്ടോമേറ്റഡ് ലിന്ററുകളും പതിവുള്ള ഫോർമാറ്റിംഗ് ആവശ്യപ്പെടുന്നു, ഇതിൽ മാറ്റം വരുത്തൽ ക്ലാർട്ടിയും സ്റ്റാൻഡേർഡിംഗും ടീമുകൾക്കായി നൽകുന്നു.
• ഉപകരണം അനുകൂലത: ചില APIs, CLIകൾ, എഡിറ്ററുകൾ തെളിവായും ലോഗിംഗിനും മനുഷ്യനെ സുഗമമായി പങ്കെടുപ്പിക്കാൻ ഫോർമാറ്റ് ചെയ്ത ഇൻപുട്ട് പ്രതീക്ഷിക്കുന്നു.

JSON ഫോർമാറ്റർ എങ്ങിനെ പ്രവർത്തിക്കുന്നു?

1. പാഴ്സിംഗ്: ആദ്യം ഈ ഫോർമാറ്റർ നിങ്ങളുടെ ഇൻപുട്ട് ടെക്സ്റ്റ് കടുത്ത JSON പാഴ്സർ ഉപയോഗിച്ച് പരിശോധിക്കും. ഇത് കൊണ്ടുള്ള പിഴവുകൾ കണ്ടെത്തുന്നു—ലിപ്യന്തരത്തിൽ കോട്ട് മറക്കൽ, കോമാ അവസാനത്ത് ഉപയോഗിക്കൽ, അൺഎസ്കേപ്പ്ഡ് അക്ഷരങ്ങൾ എന്നിവ ഉൾപ്പെടെ.
2. സുന്ദരീകരിക്കൽ: സാധാർണമായ JSON ആയാൽ, പരമ്പരാഗത 2 അല്ലെങ്കിൽ 4സ്പേസുകൾ പോലുള്ള ഇൻഡന്റേഷൻ ഉപയോഗിച്ച് വരിവിരലുകൾ ഉൾപ്പെടുത്തിയാണ് JSON വീണ്ടും സീരിയലൈസ് ചെയ്യുക, സുന്ദരീകരിച്ച പതിപ്പ് സൃഷ്ടിക്കുന്നു.

ഇൻപുട്ട് സാധുവായ JSON അല്ലെങ്കിൽ പാഴ്സിംഗ് പിഴവ് സംഭവിച്ചാൽ, പിഴവ് അറിയിപ്പ് നൽകും, പ്രശ്‌നം സംഭവിച്ച സ്ഥലം സൂചിപ്പിക്കും.

ഫോർമാറ്റിംഗ് ഓപ്ഷനുകൾ

• ഇൻഡന്റേഷൻ: ഓരോ ലെവലിലും സ്പേസുകൾ തിരഞ്ഞെടുക്കുക (പരമാവധി 8).
• ഓബ്ജക്റ്റ് കീകൾ വർണ്ണമാലാനുസാരെയുള്ള ക്രമത്തിൽ സജ്ജമാക്കുക
• സ്പേസുകളുമായി പകരം ടാബുകൾ ഉപയോഗിക്കുക
• ASCII അല്ലാത്ത അക്ഷരങ്ങളെ യൂണികോഡായി എസ്കേപ്പ് ചെയ്യുക
• ഫലിതം മിനിമൈസ് ചെയ്യുക (ഒറ്റ വരിയിൽ, സ്പേസുകൾ ഇല്ലാത്തത്)

ഫോർമാറ്റിംഗ് കൊണ്ട് പരിഹരിക്കാവുന്ന പൊതുവായ പ്രശ്നങ്ങൾ

• ഒറ്റവരി/മിനിമൈസ്ഡ് JSON: API-കളിൽ നിന്നുള്ള ഡാറ്റ അല്ലെങ്കിൽ ലോഗ് ഫയലുകൾ സാധാരണയായി ബാന്ഡ്‌വിഡ്ത്ത് കാര്യക്ഷമതക്കായി മിനിമൈസ്ഡ് ആണ്, നീണ്ടവായനയ്ക്ക് അസുഖകരം. ഫോർമാറ്റ് ചെയ്യുന്നത് വരിസ്ഥിതിൽ തിരിച്ച് വായനയോഗ്യമായും എഡിറ്റ് ചെയ്യാനും സഹായിക്കും.
• അസരളമായ ഇൻഡന്റേഷൻ: വിവിധ ഉറവിടങ്ങളിൽ നിന്നുള്ള JSON ടാബുകൾ, സ്പേസുകൾ, ഒറ്റസ്ഥായിസ് വേറിട്ട ഇൻഡന്റേഷൻ. പുനരുപയോഗം ഈ വ്യത്യാസങ്ങൾ സാധാരണമാക്കുകയും മനംമാറ്റം ക്കും സഹായിക്കും.
• വലിയ/നകേള്ള ഘടനകൾ: ആഴത്തിലുള്ള നകേള്ള അറ്രേയുകളും ഒബ്ജക്റ്റുകളും (കോൺഫിഗറേഷൻ ഫയലുകൾ, സങ്കീർണ്ണ API പ്രതികരണങ്ങൾ തുടങ്ങിയവ) ഫോർമാറ്റ് ചെയ്യുമ്പോൾ ശ്രേദ്ധാപൂർവം പരിഗണിക്കുകയും ആശ്വാസകരവും എളുപ്പത്തിൽ ബ്രൗസ് ചെയ്യാവുന്നതുമായ രൂപത്തിൽ കാണികളാക്കുകയും ചെയ്യുന്നു.

യഥാർത്ഥ ലോക ഉപയോഗദേശം: API പ്രതികരണങ്ങൾ ഫോർമാറ്റ് ചെയ്യൽ

AWS, Stripe, Google Cloud പോലെയുള്ള മൂന്നാംകക്ഷി APIs വേഗം ഉറപ്പാക്കാൻ JSON പ്രതികരണങ്ങൾ കുറഞ്ഞ ഇടത്തിലും മിനിമൈസ് ചെയ്ത രീതിയിലാണുള്ളത്. 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. നിങ്ങളുടെ_RAW, മിനിമൈസ് ചെയ്ത, അല്ലെങ്കിൽ മോശം ഫോർമാറ്റ് ചെയ്ത JSON പെയിസ്റ്റ് ചെയ്യുക അല്ലെങ്കിൽ അപ്‌ലോഡ് ചെയ്യുക.
2. ഫോർമാറ്റിംഗ് ഓപ്ഷനുകൾ തിരഞ്ഞെടുക്കുക (ഇൻഡന്റേഷൻ വലിപ്പം, കീകൾ ക്രമീകരിക്കൽ മുതലായവ).
3. "ഫോർമാറ്റ്" ക്ലിക്ക് ചെയ്ത് നിങ്ങളുടെ ഇൻപുട്ട് പ്രോസസ്സ് ചെയ്യുക.
4. വായിക്കാൻ എളുപ്പമുള്ള, ശുദ്ധമാക്കിയ আഊട്പുട്ട് കാണുക അല്ലെങ്കിൽ കോപ്പി ചെയ്യുക. പിഴവുകൾ കണ്ടെത്തിയാൽ, വിശദമായ സിന്താക്സ് സന്ദേശങ്ങൾ JSON ശരിയാക്കാൻ സഹായിക്കും.

സുരക്ഷിതമായി നിങ്ങളുടെ ഡാറ്റ നിങ്ങളുടെ ബ്രൗസറിലെ പ്രോസസ്സ് മാത്രമാണ് നടക്കുക — ഡാറ്റ എവിടെ else പോകരുത.

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)
}