ജേസൺ ഫോർമാറ്റർ & ബ്യൂട്ടിഫയർ: ഇൻഡന്റേഷൻ ഉപയോഗിച്ച് മനോഹരമായ ജേസൺ

ശരിയായ ഇൻഡന്റേഷൻ ഉപയോഗിച്ച് നിങ്ങളുടെ ജേസൺ ഡാറ്റ ഫോർമാറ്റ് ചെയ്യുകയും മനോഹരമാക്കുകയും ചെയ്യുക. കച്ചവട ജേസൺ വായിക്കാൻ എളുപ്പമാക്കുന്നു, സിന്താക്സ് ഹൈലൈറ്റിംഗ്, വാലിഡേഷൻ എന്നിവയോടെ.

ജേസൺ ഫോർമാറ്റർ

ഈ ലളിതമായ ഉപകരണത്തിലൂടെ നിങ്ങളുടെ ജേസൺ ഫോർമാറ്റ് ചെയ്യുകയും സുന്ദരമാക്കുകയും ചെയ്യുക

കച്ച ജേസൺ ഇൻപുട്ട്*

ഫോർമാറ്റ് ചെയ്ത ജേസൺ ഔട്ട്‌പുട്ട്

ഫോർമാറ്റ് ചെയ്ത ജേസൺ ഇവിടെ പ്രത്യക്ഷപ്പെടും...

📚

ഡോക്യുമെന്റേഷൻ

JSON Formatter

Introduction

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

JSON ഫോർമാറ്റിംഗ് (അഥവാ "പ്രീട്ടി പ്രിന്റിംഗ്") കച്ചവട, മിനിഫൈഡ് JSON-ന് സ്ഥിരമായ അടയാളപ്പെടുത്തലും, വരി ഇടവേളകളും, ഇടവേളകളും ചേർക്കുന്നു, JSON ഡാറ്റയുടെ ഘടനയെ ദൃശ്യമായി പ്രത്യക്ഷപ്പെടുത്തുന്നു. ഇത് സങ്കീർണ്ണമായ നസ്ട് ഒബ്ജക്റ്റുകൾ അല്ലെങ്കിൽ വലിയ ഡാറ്റാസെറ്റുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ, ഘടകങ്ങൾ തമ്മിലുള്ള ബന്ധങ്ങൾ തിരിച്ചറിയാൻ ബുദ്ധിമുട്ടാകാൻ ഇടയാക്കുന്നു.

ഞങ്ങളുടെ JSON ഫോർമാറ്റർ ഉപകരണം നിങ്ങളുടെ JSON ഡാറ്റയെ ശരിയായ അടയാളപ്പെടുത്തലും ഘടനയും ഉപയോഗിച്ച് സുന്ദരമാക്കാൻ ഒരു ലളിതമായ ഇന്റർഫേസ് നൽകുന്നു, ഇത് മനുഷ്യർക്കായി കൂടുതൽ വായിക്കാൻ എളുപ്പമാണ്, മെഷീനുകൾക്കായും അതിന്റെ സാധുത നിലനിര്‍ത്തുന്നു.

JSON Syntax and Structure

JSON രണ്ട് പ്രധാന ഘടനകളിൽ നിർമ്മിതമാണ്:

ഒബ്ജക്റ്റുകൾ: കുരുമുളക് വൃത്തങ്ങൾ {}-ൽ അടങ്ങിയ നാമം/മൂല്യങ്ങൾക്കുള്ള കൂട്ടങ്ങൾ. ഓരോ നാമത്തിനും ഒരു കോളൺ : തുടർന്നും, കൂട്ടങ്ങൾ കോമകൾ , കൊണ്ട് വേർതിരിക്കുന്നു.

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

അറേകൾ: ചതുരശ്ര വൃത്തങ്ങൾ []-ൽ അടങ്ങിയ മൂല്യങ്ങളുടെ ക്രമീകരിച്ച പട്ടികകൾ. മൂല്യങ്ങൾ കോമകൾ , കൊണ്ട് വേർതിരിക്കുന്നു.

1   ["apple", "banana", "cherry"]
2

JSON മൂല്യങ്ങൾ ആയിരിക്കും:

സ്റ്റ്രിംഗ് (ഡബിൾ ക്വോട്ട്സിൽ): "Hello World"
നമ്പറുകൾ: 42 അല്ലെങ്കിൽ 3.14159
ബൂളിയൻസ്: true അല്ലെങ്കിൽ false
നുള്ള്: null
ഒബ്ജക്റ്റുകൾ: {"key": "value"}
അറേകൾ: [1, 2, 3]

ശരിയായ JSON ഈ സിന്റാക്സ് നിയമങ്ങൾ പാലിക്കണം:

നാമങ്ങൾ ഡബിൾ ക്വോട്ട്സിൽ ആയിരിക്കണം
മൂല്യങ്ങൾ സാധുവായ JSON ഡാറ്റാ തരം ഒന്നായിരിക്കണം
അവസാന കോമകൾ അനുവദനീയമല്ല
അഭിപ്രായങ്ങൾ അനുവദനീയമല്ല
ഫംഗ്ഷനുകൾ അല്ലെങ്കിൽ രീതികൾ അനുവദനീയമല്ല

സാധാരണ സിന്റാക്സ് പിശകുകൾ ഉൾപ്പെടുന്നു:

മിസ്സിംഗ് അല്ലെങ്കിൽ മിസ്മാച്ച് ബ്രാക്കറ്റുകൾ/ബ്രേസുകൾ
പ്രോപ്പർട്ടി നാമങ്ങൾക്കുള്ള ക്വോട്ടുകൾ മിസ്സിംഗ്
പ്രോപ്പർട്ടി നാമങ്ങൾക്കുള്ള ഏകക്വോട്ടുകൾ ഉപയോഗിക്കുന്നത്
അവസാന കോമുകൾ ഉൾപ്പെടുത്തൽ
മൂല്യമായി നിർവചിച്ചിട്ടില്ലാത്തത് ഉപയോഗിക്കുന്നത്

How JSON Formatting Works

JSON ഫോർമാറ്റിംഗ് കച്ചവട, മിനിഫൈഡ് JSON-നെ വായിക്കാവുന്ന രൂപത്തിൽ മാറ്റുന്നു:

പാർസിംഗ്: JSON സ്ട്രിംഗ് ആദ്യം സാധുവായതെന്ന് ഉറപ്പാക്കുന്നതിനും ഡാറ്റാ ഘടനയുടെ മെമ്മറി പ്രതിനിധാനം സൃഷ്ടിക്കുന്നതിനും പാർസ് ചെയ്യുന്നു.
അടയാളപ്പെടുത്തൽ: ഒബ്ജക്റ്റുകൾക്കും അറേകൾക്കും ഓരോ നസ്ട് ലെവലും (സാധാരണയായി 2 അല്ലെങ്കിൽ 4 സ്പേസുകൾ) അടയാളപ്പെടുത്തുന്നു, ദൃശ്യമായി ഘടനയെ പ്രത്യക്ഷപ്പെടുത്തുന്നു.
വരി ഇടവേളകൾ: ഓരോ പ്രോപ്പർട്ടി അല്ലെങ്കിൽ അറേയുടെ ഘടകത്തിന് ശേഷം പുതിയ വരികൾ ചേർക്കുന്നു, വായനയെ മെച്ചപ്പെടുത്തുന്നു.
ഇടവേളകൾ: കോളൺസും കോമകളും ചുറ്റും സ്ഥിരമായ ഇടവേളകൾ ചേർക്കുന്നു.

ഉദാഹരണത്തിന്, ഈ മിനിഫൈഡ് JSON:

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

ഈ ഫോർമാറ്റഡ് JSON-ലേക്ക് മാറുന്നു:

1{
2  "name": "John Doe",
3  "age": 30,
4  "address": {
5    "street": "123 Main St",
6    "city": "Anytown",
7    "state": "CA"
8  },
9  "hobbies": [
10    "reading",
11    "hiking",
12    "photography"
13  ]
14}
15

ഞങ്ങളുടെ ഫോർമാറ്റർ ഓരോ ലെവലിനും 2 സ്പേസുകളുടെ സ്റ്റാൻഡേർഡ് അടയാളപ്പെടുത്തലുകൾ ഉപയോഗിക്കുന്നു, ഇത് വികസന സമൂഹത്തിൽ ഒരു സാധാരണ ആചാരമാണ്, ഇത് സങ്കുചിതത്വവും വായനാസൗകര്യവും തമ്മിൽ നല്ല സമന്വയം നൽകുന്നു.

JSON Validation

JSON ഫോർമാറ്റിംഗ് ഒരു പ്രധാന ഘടകം സാധുതയാണ്. JSON ഫോർമാറ്റ് ചെയ്യുന്നതിന് മുമ്പ്, അത് JSON സ്പെസിഫിക്കേഷനുസരിച്ച് സിന്റാക്സിക്കായി സാധുവായിരിക്കണം. സാധാരണ സാധുത പിശകുകൾ ഉൾപ്പെടുന്നു:

സിന്റാക്സ് പിശകുകൾ:
- പ്രോപ്പർട്ടി നാമങ്ങൾക്കുള്ള ക്വോട്ടുകൾ
- മിസ്സിംഗ് അല്ലെങ്കിൽ അധിക കോമകൾ
- തെറ്റായ നസ്ട് ഘടനകൾ
- അടയാളങ്ങൾ, ഒബ്ജക്റ്റുകൾ, അല്ലെങ്കിൽ അറേകൾ അടയാളപ്പെടുത്താത്തത്
ഡാറ്റാ തരം പിശകുകൾ:
- undefined അല്ലെങ്കിൽ NaN പോലെയുള്ള ജാവാസ്ക്രിപ്റ്റ്-സവിശേഷ മൂല്യങ്ങൾ ഉപയോഗിക്കുന്നത്
- ഫംഗ്ഷനുകൾ അല്ലെങ്കിൽ രീതികൾ ഉൾപ്പെടുത്തൽ
- സ്റ്റ്രിംഗുകൾക്കായി ഏകക്വോട്ടുകൾ ഉപയോഗിക്കുന്നത്

നിങ്ങൾ അസാധുവായ JSON-നൊപ്പം നേരിടുമ്പോൾ, പിശക് സന്ദേശം പ്രശ്നം തിരിച്ചറിയാൻ സഹായിക്കുന്നു. JSON പാർസറുകൾ സാധാരണയായി പാർസിംഗ് പരാജയപ്പെട്ട സ്ഥലത്തെ സൂചിപ്പിക്കും, ഇത് പ്രശ്നം കണ്ടെത്താൻ സഹായിക്കുന്നു. ഞങ്ങളുടെ ഉപകരണം നിങ്ങളുടെ JSON ഡാറ്റയിൽ പ്രശ്നങ്ങൾ തിരിച്ചറിയാനും പരിഹരിക്കാനും സഹായിക്കുന്ന വ്യക്തമായ പിശക് സന്ദേശങ്ങൾ നൽകുന്നു.

Use Cases

JSON ഫോർമാറ്റിംഗ് നിരവധി സാഹചര്യങ്ങളിൽ മൂല്യവത്തായതാണ്:

API വികസനം ಮತ್ತು പരിശോധന

RESTful APIs-നൊപ്പം പ്രവർത്തിക്കുമ്പോൾ, ഫോർമാറ്റഡ് JSON വായിക്കാൻ എളുപ്പമാണ്:

പ്രതികരണ പെയ്ലോഡുകൾ പരിശോധിക്കുക
അഭ്യർത്ഥന ശരീരങ്ങൾ ഡീബഗ് ചെയ്യുക
API ഉദാഹരണങ്ങൾ രേഖപ്പെടുത്തുക
ഡാറ്റാ ഘടനകൾ പ്രതീക്ഷകൾക്ക് അനുയോജ്യമായതായി സ്ഥിരീകരിക്കുക

കോൺഫിഗറേഷൻ മാനേജ്മെന്റ്

അധികം ആധുനിക ആപ്ലിക്കേഷനുകൾ JSON-നെ കോൺഫിഗറേഷനായി ഉപയോഗിക്കുന്നു:

ആപ്ലിക്കേഷൻ ക്രമീകരണ ഫയലുകൾ
പരിസ്ഥിതി ക്രമീകരണങ്ങൾ
നിർമ്മാണവും വിന്യാസവും സംബന്ധിച്ച സ്പെസിഫിക്കേഷനുകൾ
ഇൻഫ്രാസ്ട്രക്ചർ ആസ് കോഡ് ടെംപ്ലേറ്റുകൾ (ഉദാ: AWS CloudFormation, Terraform)

ഡാറ്റാ വിശകലനവും കാഴ്ചവെക്കലും

ഫോർമാറ്റഡ് JSON സഹായിക്കുന്നു:

ഡാറ്റാസെറ്റുകൾ പരിശോധിക്കുക
കാഴ്ചവെക്കലിന് ഡാറ്റ തയ്യാറാക്കുക
ഡാറ്റാ സ്കീമകൾ മനസ്സിലാക്കുക
ഘടിത ഡാറ്റയിൽ മാതൃകകൾ തിരിച്ചറിയുക

ഡീബഗിംഗ്, പ്രശ്നപരിഹാരം

ശരിയായ JSON ഫോർമാറ്റിംഗ് അനിവാര്യമാണ്:

വെബ് ആപ്ലിക്കേഷനുകൾ ഡീബഗ് ചെയ്യുമ്പോൾ
localStorage അല്ലെങ്കിൽ sessionStorage പരിശോധിക്കുമ്പോൾ
നെറ്റ്‌വർക്ക് പ്രതികരണങ്ങൾ വിശകലനം ചെയ്യുമ്പോൾ
ഡാറ്റാ ഇന്റഗ്രേഷൻ പ്രശ്നങ്ങൾ പരിഹരിക്കുമ്പോൾ

വിദ്യാഭ്യാസ ആവശ്യങ്ങൾ

വായനാസൗകര്യമുള്ള JSON ഫോർമാറ്റിംഗ്:

ഡാറ്റാ ഘടനകൾ പഠിപ്പിക്കുമ്പോൾ
നസ്ട് ബന്ധങ്ങൾ പ്രദർശിപ്പിക്കുമ്പോൾ
API ആശയങ്ങൾ വിശദീകരിക്കുമ്പോൾ
ഡാറ്റാ മോഡലിംഗ് തത്വങ്ങൾ വിശദീകരിക്കുമ്പോൾ

Alternatives

ഞങ്ങളുടെ വെബ് അടിസ്ഥാന JSON ഫോർമാറ്റർ വേഗത്തിൽ ഫോർമാറ്റിംഗ് ജോലികൾക്കായി സൗകര്യപ്രദമാണ്, എന്നാൽ വിവിധ സാഹചര്യങ്ങൾക്ക് നിരവധി പര്യായങ്ങൾ ഉണ്ട്:

ബ്രൗസർ ഡെവലപ്പർ ടൂളുകൾ

ആധുനിക ബ്രൗസറുകൾ JSON ഫോർമാറ്റിംഗ് കഴിവുകൾ ഉൾക്കൊള്ളുന്നു:

Chrome, Edge DevTools നെറ്റ്‌വർക്ക് ടാബിൽ JSON പ്രതികരണങ്ങൾ സ്വയം ഫോർമാറ്റ് ചെയ്യുന്നു
Firefox-ന്റെ JSON ദർശകൻ സംവേദനാത്മകമായ മരവിപ്പുള്ള കാഴ്ച നൽകുന്നു
JSONView പോലുള്ള ബ്രൗസർ വിപുലീകരണങ്ങൾ JSON-നെ നേരിട്ട് ബ്രൗസറിൽ ഫോർമാറ്റ് ചെയ്യാൻ കഴിയും

കോഡ് എഡിറ്ററുകൾ, IDEകൾ

അധികം വികസന പരിസരങ്ങൾ JSON ഫോർമാറ്റിംഗ് നൽകുന്നു:

Visual Studio Code-ൽ JSON ഫോർമാറ്റിംഗ് ഉൾപ്പെടുന്നു (Alt+Shift+F)
JetBrains IDEs (WebStorm, IntelliJ) ശക്തമായ JSON ഉപകരണങ്ങൾ ഉൾക്കൊള്ളുന്നു
Sublime Text, Atom പ്ലഗിനുകൾ വഴി JSON ഫോർമാറ്റിംഗ് പിന്തുണയ്ക്കുന്നു

കമാൻഡ് ലൈൻ ഉപകരണങ്ങൾ

ടെർമിനൽ ഉപയോക്താക്കൾക്കോ ഓട്ടോമേഷൻക്കോ:

jq ഒരു ശക്തമായ കമാൻഡ്-ലൈൻ JSON പ്രോസസ്സർ ആണ്
json_pp പല Unix സിസ്റ്റങ്ങളിൽ മുൻകൂട്ടി ഇൻസ്റ്റാൾ ചെയ്യുന്നു
python -m json.tool Python ഉപയോഗിച്ച് വേഗത്തിൽ ഫോർമാറ്റിംഗ് നൽകുന്നു

പ്രോഗ്രാമാറ്റിക് സമീപനങ്ങൾ

ആപ്ലിക്കേഷനുകൾക്കുള്ള JSON-നെ ഫോർമാറ്റ് ചെയ്യുമ്പോൾ:

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

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

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

1# Ruby
2require 'json'
3formatted = JSON.pretty_generate(json_object)
4

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

History

JSON ഡഗ്ലസ് ക്രോക്ക്ഫോർഡ് 2000-കളുടെ ആദ്യം ഒരു ലഘുവായ XML-ന്റെ പ്രത്യയശാസ്ത്രം ആയി സൃഷ്ടിച്ചു. ഈ ഫോർമാറ്റ് ജാവാസ്ക്രിപ്റ്റ് ഒബ്ജക്റ്റ് ലിറ്ററൽ സിന്റാക്സിൽ നിന്നാണ് ഉത്ഭവിച്ചത്, എന്നാൽ ഭാഷാ-സ്വതന്ത്രമായിരിക്കുവാൻ രൂപകൽപ്പന ചെയ്തതാണ്. 2006-ൽ JSON ഔദ്യോഗികമായി RFC 4627-ൽ വ്യക്തമാക്കിയിട്ടുണ്ട്, അതിന്റെ സിമ്പ്ലിസിറ്റിയും ജാവാസ്ക്രിപ്റ്റുമായുള്ള അനുയോജ്യതയും കാരണം അതിന്റെ ജനപ്രിയതിയും വേഗത്തിൽ വർദ്ധിച്ചു.

JSON-നുമുമ്പ് XML ഡാറ്റാ ഇടപാടുകൾക്കായി പ്രധാനമായ ഫോർമാറ്റ് ആയിരുന്നു, എന്നാൽ അതിന്റെ വലുപ്പവും സങ്കീർണ്ണതയും പല ആപ്ലിക്കേഷനുകൾക്കായി അതിനെ ബുദ്ധിമുട്ടാക്കുന്നു. JSON ഒരു കൂടുതൽ സംക്ഷിപ്തമായ സിന്റാക്സ് നൽകുന്നു, അത് വായിക്കാൻ, എഴുതാൻ, മനുഷ്യർക്കും മെഷീനുകൾക്കുമായി എളുപ്പമാണ്. ഇത് ജാവാസ്ക്രിപ്റ്റിന്റെ ഒബ്ജക്റ്റ് മോഡലുമായി പൂർണ്ണമായും പൊരുത്തപ്പെടുന്നു, അതിനാൽ വെബ് ആപ്ലിക്കേഷനുകൾക്കായി സ്വാഭാവികമായ തിരഞ്ഞെടുപ്പാണ്.

JSON-ന്റെ സ്വീകരണം 2000-കളുടെ മധ്യത്തിൽ AJAX, RESTful APIs എന്നിവയുടെ ഉയർച്ചയോടെ വേഗത്തിൽ വർദ്ധിച്ചു. 2010-കളുടെ ആരംഭത്തിൽ, ഇത് വെബ് APIs, കോൺഫിഗറേഷൻ ഫയലുകൾ, NoSQL ഡാറ്റാബേസുകളിൽ ഡാറ്റാ സംഭരണത്തിനായി ഡിഫാക്ടോ സ്റ്റാൻഡേർഡ് ആയി മാറി, ഉദാ: MongoDB, CouchDB.

ഇന്ന്, JSON prácticamente എല്ലാ പ്രോഗ്രാമിംഗ് ഭാഷകളാൽ പിന്തുണയ്ക്കുന്നു, വെബ് ആപ്ലിക്കേഷനുകളിൽ അനവധി ഉപയോഗിക്കുന്നു. അതിന്റെ സിമ്പ്ലിസിറ്റിയും, ഫ്ലെക്സിബിലിറ്റിയും, സർവ്വവ്യാപകമായ പിന്തുണയും കാരണം, ഇത് ആധുനിക കംപ്യൂട്ടിങ്ങിൽ ഏറ്റവും പ്രധാനപ്പെട്ട ഡാറ്റാ ഫോർമാറ്റുകളിൽ ഒന്നായി മാറിയിട്ടുണ്ട്.

Code Examples

ഇവിടെ വിവിധ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ JSON ഫോർമാറ്റിംഗ് എങ്ങനെ ചെയ്യാമെന്ന് ഉദാഹരണങ്ങൾ:

1// JavaScript JSON formatting
2function formatJSON(jsonString) {
3  try {
4    const parsedData = JSON.parse(jsonString);
5    return JSON.stringify(parsedData, null, 2);
6  } catch (error) {
7    return `Error: ${error.message}`;
8  }
9}
10
11// Example usage
12const rawJSON = '{"name":"John","age":30,"city":"New York"}';
13console.log(formatJSON(rawJSON));
14

1# Python JSON formatting
2import json
3
4def format_json(json_string):
5    try:
6        parsed_data = json.loads(json_string)
7        return json.dumps(parsed_data, indent=2)
8    except json.JSONDecodeError as e:
9        return f"Error: {str(e)}"
10
11# Example usage
12raw_json = '{"name":"John","age":30,"city":"New York"}'
13print(format_json(raw_json))
14

1// Java JSON formatting with Gson
2import com.google.gson.Gson;
3import com.google.gson.GsonBuilder;
4import com.google.gson.JsonSyntaxException;
5
6public class JSONFormatter {
7    public static String formatJSON(String jsonString) {
8        try {
9            Gson gson = new GsonBuilder().setPrettyPrinting().create();
10            Object parsedJson = gson.fromJson(jsonString, Object.class);
11            return gson.toJson(parsedJson);
12        } catch (JsonSyntaxException e) {
13            return "Error: " + e.getMessage();
14        }
15    }
16    
17    public static void main(String[] args) {
18        String rawJSON = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}";
19        System.out.println(formatJSON(rawJSON));
20    }
21}
22

1// PHP JSON formatting
2function formatJSON($jsonString) {
3    $result = json_decode($jsonString);
4    if (json_last_error() !== JSON_ERROR_NONE) {
5        return "Error: " . json_last_error_msg();
6    }
7    return json_encode($result, JSON_PRETTY_PRINT);
8}
9
10// Example usage
11$rawJSON = '{"name":"John","age":30,"city":"New York"}';
12echo formatJSON($rawJSON);
13

1# Ruby JSON formatting
2require 'json'
3
4def format_json(json_string)
5  begin
6    parsed_data = JSON.parse(json_string)
7    return JSON.pretty_generate(parsed_data)
8  rescue JSON::ParserError => e
9    return "Error: #{e.message}"
10  end
11end
12
13# Example usage
14raw_json = '{"name":"John","age":30,"city":"New York"}'
15puts format_json(raw_json)
16

1// C# JSON formatting with Newtonsoft.Json
2using Newtonsoft.Json;
3using System;
4
5class JSONFormatter
6{
7    public static string FormatJSON(string jsonString)
8    {
9        try
10        {
11            object parsedJson = JsonConvert.DeserializeObject(jsonString);
12            return JsonConvert.SerializeObject(parsedJson, Formatting.Indented);
13        }
14        catch (JsonException e)
15        {
16            return $"Error: {e.Message}";
17        }
18    }
19    
20    static void Main()
21    {
22        string rawJSON = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}";
23        Console.WriteLine(FormatJSON(rawJSON));
24    }
25}
26

1// Go JSON formatting
2package main
3
4import (
5    "encoding/json"
6    "fmt"
7)
8
9func formatJSON(jsonString string) string {
10    var parsedData interface{}
11    err := json.Unmarshal([]byte(jsonString), &parsedData)
12    if err != nil {
13        return fmt.Sprintf("Error: %s", err.Error())
14    }
15    
16    formattedBytes, err := json.MarshalIndent(parsedData, "", "  ")
17    if err != nil {
18        return fmt.Sprintf("Error: %s", err.Error())
19    }
20    
21    return string(formattedBytes)
22}
23
24func main() {
25    rawJSON := `{"name":"John","age":30,"city":"New York"}`
26    fmt.Println(formatJSON(rawJSON))
27}
28

Edge Cases and Considerations

JSON ഫോർമാറ്റിംഗ് ചെയ്യുമ്പോൾ, ഈ സാധ്യതയുള്ള വെല്ലുവിളികൾക്കായി ജാഗ്രത പുലർത്തുക:

വലിയ JSON ഫയലുകൾ

വളരെ വലിയ JSON ഫയലുകൾ (ചില മേഘങ്ങൾ അല്ലെങ്കിൽ കൂടുതൽ) ബ്രൗസർ അടിസ്ഥാന ഫോർമാറ്ററുകളിൽ പ്രവർത്തന പ്രശ്നങ്ങൾ ഉണ്ടാക്കാം. ഇത്തരം കേസുകളിൽ:

കമാൻഡ് ലൈൻ ഉപകരണങ്ങൾ ഉപയോഗിക്കുക, ഉദാ: jq
JSON-നെ ചെറിയ ഭാഗങ്ങളായി വിഭജിക്കുക
മുഴുവൻ ഫയൽ മെമ്മറിയിൽ ലോഡ് ചെയ്യാതെ പ്രോസസിംഗിന് സ്ട്രീമിംഗ് പാർസറുകൾ ഉപയോഗിക്കുക

ഗഹനമായ നസ്ട് ഘടനകൾ

അത്യന്തം നസ്ട് JSON (10-20 ലെവലുകൾക്കുപരം) ഫോർമാറ്റുചെയ്യുമ്പോൾ പോലും നാവിഗേറ്റ് ചെയ്യാൻ ബുദ്ധിമുട്ടായേക്കാം. ഈ സാഹചര്യങ്ങളിൽ:

ഘടനയെ സമതലമാക്കാൻ ശ്രമിക്കുക
ചുരുക്കം JSON ദർശകങ്ങൾ ഉപയോഗിക്കുക
JSON-ന്റെ പ്രത്യേക ഭാഗങ്ങൾക്കൊപ്പം പ്രവർത്തിക്കുക

പ്രത്യേക അക്ഷരങ്ങൾ, യൂണികോഡ്

JSON യൂണികോഡ് പിന്തുണയ്ക്കുന്നു, എന്നാൽ ചില ഫോർമാറ്ററുകൾക്ക് ചില അക്ഷരങ്ങളുമായി പ്രശ്നങ്ങൾ ഉണ്ടാകാം:

നിങ്ങളുടെ ഫോർമാറ്റർ ഇമോജി, മറ്റ് യൂണികോഡ് അക്ഷരങ്ങൾ ശരിയായി കൈകാര്യം ചെയ്യുന്നതെന്ന് ഉറപ്പാക്കുക
നിയന്ത്രണ അക്ഷരങ്ങൾ, എസ്കേപ്പ് സീക്വൻസുകൾക്കൊപ്പം ജാഗ്രത പുലർത്തുക
ഫോർമാറ്റുചെയ്ത ഔട്ട്‌പുട്ട് എല്ലാ പ്രാഥമിക അക്ഷരങ്ങളും നിലനിര്‍ത്തുന്നതെന്ന് സ്ഥിരീകരിക്കുക

സംഖ്യാ കൃത്യത

JSON സംഖ്യകളുടെ കൃത്യത വ്യക്തമാക്കുന്നില്ല, ഇത് വളരെ വലിയ ഇന്റേജറുകൾ അല്ലെങ്കിൽ ഫ്ലോട്ടിംഗ്-പോയിന്റ് മൂല്യങ്ങൾക്കൊപ്പം പ്രശ്നങ്ങൾ ഉണ്ടാക്കാം:

53 ബിറ്റുകൾക്കുപരം ഇന്റേജറുകൾക്കായി ചില ജാവാസ്ക്രിപ്റ്റ് നടപ്പുകൾ കൃത്യത നഷ്ടപ്പെടാൻ സാധ്യതയുണ്ട്
കൃത്യമായ സംഖ്യാ മൂല്യങ്ങൾക്കായി സ്റ്റ്രിംഗ് പ്രതിനിധാനങ്ങൾ ഉപയോഗിക്കുക
നിങ്ങളുടെ ആപ്ലിക്കേഷനിൽ ഉയർന്ന കൃത്യത ആവശ്യമുണ്ടെങ്കിൽ അതിന്റെ മൂല്യങ്ങൾക്കൊപ്പം പരീക്ഷിക്കുക

ശൂന്യമായ ഒബ്ജക്റ്റുകൾ, അറേകൾ

സാധുവായ JSON ശൂന്യമായ ഒബ്ജക്റ്റുകൾ {}-യും അറേകൾ []-യും ഉൾക്കൊള്ളുന്നു, ഇത് ശരിയായ രീതിയിൽ ഫോർമാറ്റ് ചെയ്യണം:

ശൂന്യമായ ഒബ്ജക്റ്റുകൾ {} എന്ന രൂപത്തിൽ കാണപ്പെടണം
ശൂന്യമായ അറേകൾ [] എന്ന രൂപത്തിൽ കാണപ്പെടണം
നസ്ട് ശൂന്യമായ ഘടനകൾ ശരിയായ അടയാളപ്പെടുത്തലുകൾ നിലനിര്‍ത്തണം

References

JSON.org - JSON സ്പെസിഫിക്കേഷന്റെ ഔദ്യോഗിക വെബ്‌സൈറ്റ്
RFC 8259 - JSON ഡാറ്റാ ഇടപാടിന്റെ ഫോർമാറ്റ്
MDN വെബ് ഡോക്സ്: JSON - ജാവാസ്ക്രിപ്റ്റിൽ JSON-ന്റെ സമഗ്ര രേഖകൾ
JSON Lint - പ്രശസ്തമായ ഓൺലൈൻ JSON വാലിഡേറ്റർ
jq - ഒരു ലഘുവായ, ഫ്ലെക്സിബിൾ കമാൻഡ്-ലൈൻ JSON പ്രോസസ്സർ

💬

പ്രതികരണം

💬

ഈ ഉപകരണത്തെക്കുറിച്ച് പ്രതികരണം നൽകാൻ പ്രതികരണ ടോസ്റ്റിൽ ക്ലിക്ക് ചെയ്യുക

🔗

ബന്ധപ്പെട്ട ഉപകരണങ്ങൾ

നിങ്ങളുടെ പ്രവൃത്തി പ്രവാഹത്തിന് ഉപകാരപ്രദമായ കൂടുതൽ ഉപകരണങ്ങൾ കണ്ടെത്തുക

ജേസൺ താരതമ്യ ഉപകരണം: ജേസൺ ഓബ്ജക്റ്റുകൾ തമ്മിലുള്ള വ്യത്യാസങ്ങൾ കണ്ടെത്തുക

ഈ ഉപകരണം പരീക്ഷിക്കുക

റെഗുലർ എക്സ്പ്രഷൻ പാറ്റേൺ ടെസ്റ്റർ & വാലിഡേറ്റർ: ടെസ്റ്റ്, ഹൈലൈറ്റ് & സേവ് പാറ്റേണുകൾ

ഈ ഉപകരണം പരീക്ഷിക്കുക

പരീക്ഷണത്തിനും സ്ഥിരീകരണത്തിനും വേണ്ടി IBAN സൃഷ്ടിക്കാനും സ്ഥിരീകരിക്കാനും ഉപകരണം

ഈ ഉപകരണം പരീക്ഷിക്കുക

ജേസൺ ഫോർമാറ്റർ & ബ്യൂട്ടിഫയർ: ഇൻഡന്റേഷൻ ഉപയോഗിച്ച് മനോഹരമായ ജേസൺ

ജേസൺ ഫോർമാറ്റർ

ഡോക്യുമെന്റേഷൻ

JSON Formatter

Introduction

JSON Syntax and Structure

How JSON Formatting Works

JSON Validation

Use Cases

API വികസനം ಮತ್ತು പരിശോധന

കോൺഫിഗറേഷൻ മാനേജ്മെന്റ്

ഡാറ്റാ വിശകലനവും കാഴ്ചവെക്കലും

ഡീബഗിംഗ്, പ്രശ്നപരിഹാരം

വിദ്യാഭ്യാസ ആവശ്യങ്ങൾ

Alternatives

ബ്രൗസർ ഡെവലപ്പർ ടൂളുകൾ

കോഡ് എഡിറ്ററുകൾ, IDEകൾ

കമാൻഡ് ലൈൻ ഉപകരണങ്ങൾ

പ്രോഗ്രാമാറ്റിക് സമീപനങ്ങൾ

History

Code Examples

Edge Cases and Considerations

വലിയ JSON ഫയലുകൾ

ഗഹനമായ നസ്ട് ഘടനകൾ

പ്രത്യേക അക്ഷരങ്ങൾ, യൂണികോഡ്

സംഖ്യാ കൃത്യത

ശൂന്യമായ ഒബ്ജക്റ്റുകൾ, അറേകൾ

References

പ്രതികരണം

ബന്ധപ്പെട്ട ഉപകരണങ്ങൾ

ജേസൺ താരതമ്യ ഉപകരണം: ജേസൺ ഓബ്ജക്റ്റുകൾ തമ്മിലുള്ള വ്യത്യാസങ്ങൾ കണ്ടെത്തുക

റെഗുലർ എക്സ്പ്രഷൻ പാറ്റേൺ ടെസ്റ്റർ & വാലിഡേറ്റർ: ടെസ്റ്റ്, ഹൈലൈറ്റ് & സേവ് പാറ്റേണുകൾ

CSS മിനിഫയർ ടൂൾ: ഓൺലൈൻ CSS കോഡ് ഒപ്റ്റിമൈസ് & കംപ്രസ് ചെയ്യുക

ബൈനറി-ഡെസിമൽ കൺവെർട്ടർ: നമ്പർ സിസ്റ്റങ്ങൾക്കിടയിൽ മാറ്റം

സംഖ്യാ അടിസ്ഥാന മാറ്റാൻ: ബൈനറി, ദശമലവം, ഹെക്സും ഇഷ്ടാനുസൃത അടിസ്ഥാനങ്ങളും

സമയം യൂണിറ്റ് പരിവർത്തകൻ: വർഷങ്ങൾ, ദിവസങ്ങൾ, മണിക്കൂറുകൾ, മിനിറ്റുകൾ, സെക്കൻഡ്

ബേസ്64 എൻകോഡർ & ഡീകോഡർ: ടെക്സ്റ്റ് ബേസ്64-ലേക്ക്/ലേക്ക് മാറ്റുക

ਟੈਕਸਟ ਇਨਵਰਟਰ ਟੂਲ: ਕਿਸੇ ਵੀ ਸਤਰ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਕ੍ਰਮ ਨੂੰ ਉਲਟਣਾ

പരീക്ഷണത്തിനും സ്ഥിരീകരണത്തിനും വേണ്ടി IBAN സൃഷ്ടിക്കാനും സ്ഥിരീകരിക്കാനും ഉപകരണം