ശരിയായ ഇൻഡന്റേഷൻ ഉപയോഗിച്ച് നിങ്ങളുടെ ജേസൺ ഡാറ്റ ഫോർമാറ്റ് ചെയ്യുകയും മനോഹരമാക്കുകയും ചെയ്യുക. കച്ചവട ജേസൺ വായിക്കാൻ എളുപ്പമാക്കുന്നു, സിന്താക്സ് ഹൈലൈറ്റിംഗ്, വാലിഡേഷൻ എന്നിവയോടെ.
ഈ ലളിതമായ ഉപകരണത്തിലൂടെ നിങ്ങളുടെ ജേസൺ ഫോർമാറ്റ് ചെയ്യുകയും സുന്ദരമാക്കുകയും ചെയ്യുക
ഫോർമാറ്റ് ചെയ്ത ജേസൺ ഇവിടെ പ്രത്യക്ഷപ്പെടും...
JSON (ജാവാസ്ക്രിപ്റ്റ് ഒബ്ജക്റ്റ് നോട്ടേഷൻ) ഒരു ലഘുവായ ഡാറ്റാ ഇടപാടിന്റെ ഫോർമാറ്റ് ആണ്, ഇത് വെബ് ആപ്ലിക്കേഷനുകളിൽ ഡാറ്റാ കൈമാറ്റത്തിനുള്ള സ്റ്റാൻഡേർഡ് ആയി മാറിയിട്ടുണ്ട്. അതിന്റെ സിമ്പ്ലിസിറ്റിക്ക് rağmen, JSON ഡാറ്റ മിനിഫൈഡ് അല്ലെങ്കിൽ ശരിയായ ഫോർമാറ്റ് ഇല്ലാത്തപ്പോൾ വായിക്കാൻ ബുദ്ധിമുട്ടായേക്കാം. ഈ ഉപകരണം കച്ചവടം, അക്രമിതമായ JSON സ്ട്രിംഗ്‌കളെ നല്ല രീതിയിൽ ഘടിപ്പിച്ച, അടയാളപ്പെടുത്തലുള്ള ഫോർമാറ്റിലേക്ക് മാറ്റാൻ സഹായിക്കുന്നു, അത് വായിക്കാൻ കൂടുതൽ എളുപ്പമാണ്.
JSON ഫോർമാറ്റിംഗ് (അഥവാ "പ്രീട്ടി പ്രിന്റിംഗ്") കച്ചവട, മിനിഫൈഡ് JSON-ന് സ്ഥിരമായ അടയാളപ്പെടുത്തലും, വരി ഇടവേളകളും, ഇടവേളകളും ചേർക്കുന്നു, JSON ഡാറ്റയുടെ ഘടനയെ ദൃശ്യമായി പ്രത്യക്ഷപ്പെടുത്തുന്നു. ഇത് സങ്കീർണ്ണമായ നസ്ട് ഒബ്ജക്റ്റുകൾ അല്ലെങ്കിൽ വലിയ ഡാറ്റാസെറ്റുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ, ഘടകങ്ങൾ തമ്മിലുള്ള ബന്ധങ്ങൾ തിരിച്ചറിയാൻ ബുദ്ധിമുട്ടാകാൻ ഇടയാക്കുന്നു.
ഞങ്ങളുടെ JSON ഫോർമാറ്റർ ഉപകരണം നിങ്ങളുടെ JSON ഡാറ്റയെ ശരിയായ അടയാളപ്പെടുത്തലും ഘടനയും ഉപയോഗിച്ച് സുന്ദരമാക്കാൻ ഒരു ലളിതമായ ഇന്റർഫേസ് നൽകുന്നു, ഇത് മനുഷ്യർക്കായി കൂടുതൽ വായിക്കാൻ എളുപ്പമാണ്, മെഷീനുകൾക്കായും അതിന്റെ സാധുത നിലനിര്‍ത്തുന്നു.
JSON രണ്ട് പ്രധാന ഘടനകളിൽ നിർമ്മിതമാണ്:
{}-ൽ അടങ്ങിയ നാമം/മൂല്യങ്ങൾക്കുള്ള കൂട്ടങ്ങൾ. ഓരോ നാമത്തിനും ഒരു കോളൺ : തുടർന്നും, കൂട്ടങ്ങൾ കോമകൾ , കൊണ്ട് വേർതിരിക്കുന്നു.1 {"name": "John", "age": 30, "city": "New York"}
2 []-ൽ അടങ്ങിയ മൂല്യങ്ങളുടെ ക്രമീകരിച്ച പട്ടികകൾ. മൂല്യങ്ങൾ കോമകൾ , കൊണ്ട് വേർതിരിക്കുന്നു.1 ["apple", "banana", "cherry"]
2 JSON മൂല്യങ്ങൾ ആയിരിക്കും:
"Hello World"42 അല്ലെങ്കിൽ 3.14159true അല്ലെങ്കിൽ falsenull{"key": "value"}[1, 2, 3]ശരിയായ JSON ഈ സിന്റാക്സ് നിയമങ്ങൾ പാലിക്കണം:
സാധാരണ സിന്റാക്സ് പിശകുകൾ ഉൾപ്പെടുന്നു:
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 ഫോർമാറ്റിംഗ് ഒരു പ്രധാന ഘടകം സാധുതയാണ്. JSON ഫോർമാറ്റ് ചെയ്യുന്നതിന് മുമ്പ്, അത് JSON സ്പെസിഫിക്കേഷനുസരിച്ച് സിന്റാക്സിക്കായി സാധുവായിരിക്കണം. സാധാരണ സാധുത പിശകുകൾ ഉൾപ്പെടുന്നു:
സിന്റാക്സ് പിശകുകൾ:
ഡാറ്റാ തരം പിശകുകൾ:
undefined അല്ലെങ്കിൽ NaN പോലെയുള്ള ജാവാസ്ക്രിപ്റ്റ്-സവിശേഷ മൂല്യങ്ങൾ ഉപയോഗിക്കുന്നത്നിങ്ങൾ അസാധുവായ JSON-നൊപ്പം നേരിടുമ്പോൾ, പിശക് സന്ദേശം പ്രശ്നം തിരിച്ചറിയാൻ സഹായിക്കുന്നു. JSON പാർസറുകൾ സാധാരണയായി പാർസിംഗ് പരാജയപ്പെട്ട സ്ഥലത്തെ സൂചിപ്പിക്കും, ഇത് പ്രശ്നം കണ്ടെത്താൻ സഹായിക്കുന്നു. ഞങ്ങളുടെ ഉപകരണം നിങ്ങളുടെ JSON ഡാറ്റയിൽ പ്രശ്നങ്ങൾ തിരിച്ചറിയാനും പരിഹരിക്കാനും സഹായിക്കുന്ന വ്യക്തമായ പിശക് സന്ദേശങ്ങൾ നൽകുന്നു.
JSON ഫോർമാറ്റിംഗ് നിരവധി സാഹചര്യങ്ങളിൽ മൂല്യവത്തായതാണ്:
RESTful APIs-നൊപ്പം പ്രവർത്തിക്കുമ്പോൾ, ഫോർമാറ്റഡ് JSON വായിക്കാൻ എളുപ്പമാണ്:
അധികം ആധുനിക ആപ്ലിക്കേഷനുകൾ JSON-നെ കോൺഫിഗറേഷനായി ഉപയോഗിക്കുന്നു:
ഫോർമാറ്റഡ് JSON സഹായിക്കുന്നു:
ശരിയായ JSON ഫോർമാറ്റിംഗ് അനിവാര്യമാണ്:
വായനാസൗകര്യമുള്ള JSON ഫോർമാറ്റിംഗ്:
ഞങ്ങളുടെ വെബ് അടിസ്ഥാന JSON ഫോർമാറ്റർ വേഗത്തിൽ ഫോർമാറ്റിംഗ് ജോലികൾക്കായി സൗകര്യപ്രദമാണ്, എന്നാൽ വിവിധ സാഹചര്യങ്ങൾക്ക് നിരവധി പര്യായങ്ങൾ ഉണ്ട്:
ആധുനിക ബ്രൗസറുകൾ JSON ഫോർമാറ്റിംഗ് കഴിവുകൾ ഉൾക്കൊള്ളുന്നു:
അധികം വികസന പരിസരങ്ങൾ JSON ഫോർമാറ്റിംഗ് നൽകുന്നു:
ടെർമിനൽ ഉപയോക്താക്കൾക്കോ ഓട്ടോമേഷൻക്കോ:
jq ഒരു ശക്തമായ കമാൻഡ്-ലൈൻ JSON പ്രോസസ്സർ ആണ്json_pp പല Unix സിസ്റ്റങ്ങളിൽ മുൻകൂട്ടി ഇൻസ്റ്റാൾ ചെയ്യുന്നുpython -m json.tool Python ഉപയോഗിച്ച് വേഗത്തിൽ ഫോർമാറ്റിംഗ് നൽകുന്നുആപ്ലിക്കേഷനുകൾക്കുള്ള JSON-നെ ഫോർമാറ്റ് ചെയ്യുമ്പോൾ:
1// JavaScript
2const formatted = JSON.stringify(jsonObject, null, 2);
31# Python
2import json
3formatted = json.dumps(json_object, indent=2)
41// Java with Gson
2Gson gson = new GsonBuilder().setPrettyPrinting().create();
3String formatted = gson.toJson(jsonObject);
41# Ruby
2require 'json'
3formatted = JSON.pretty_generate(json_object)
41// PHP
2$formatted = json_encode($jsonObject, JSON_PRETTY_PRINT);
3JSON ഡഗ്ലസ് ക്രോക്ക്ഫോർഡ് 2000-കളുടെ ആദ്യം ഒരു ലഘുവായ XML-ന്റെ പ്രത്യയശാസ്ത്രം ആയി സൃഷ്ടിച്ചു. ഈ ഫോർമാറ്റ് ജാവാസ്ക്രിപ്റ്റ് ഒബ്ജക്റ്റ് ലിറ്ററൽ സിന്റാക്സിൽ നിന്നാണ് ഉത്ഭവിച്ചത്, എന്നാൽ ഭാഷാ-സ്വതന്ത്രമായിരിക്കുവാൻ രൂപകൽപ്പന ചെയ്തതാണ്. 2006-ൽ JSON ഔദ്യോഗികമായി RFC 4627-ൽ വ്യക്തമാക്കിയിട്ടുണ്ട്, അതിന്റെ സിമ്പ്ലിസിറ്റിയും ജാവാസ്ക്രിപ്റ്റുമായുള്ള അനുയോജ്യതയും കാരണം അതിന്റെ ജനപ്രിയതിയും വേഗത്തിൽ വർദ്ധിച്ചു.
JSON-നുമുമ്പ് XML ഡാറ്റാ ഇടപാടുകൾക്കായി പ്രധാനമായ ഫോർമാറ്റ് ആയിരുന്നു, എന്നാൽ അതിന്റെ വലുപ്പവും സങ്കീർണ്ണതയും പല ആപ്ലിക്കേഷനുകൾക്കായി അതിനെ ബുദ്ധിമുട്ടാക്കുന്നു. JSON ഒരു കൂടുതൽ സംക്ഷിപ്തമായ സിന്റാക്സ് നൽകുന്നു, അത് വായിക്കാൻ, എഴുതാൻ, മനുഷ്യർക്കും മെഷീനുകൾക്കുമായി എളുപ്പമാണ്. ഇത് ജാവാസ്ക്രിപ്റ്റിന്റെ ഒബ്ജക്റ്റ് മോഡലുമായി പൂർണ്ണമായും പൊരുത്തപ്പെടുന്നു, അതിനാൽ വെബ് ആപ്ലിക്കേഷനുകൾക്കായി സ്വാഭാവികമായ തിരഞ്ഞെടുപ്പാണ്.
JSON-ന്റെ സ്വീകരണം 2000-കളുടെ മധ്യത്തിൽ AJAX, RESTful APIs എന്നിവയുടെ ഉയർച്ചയോടെ വേഗത്തിൽ വർദ്ധിച്ചു. 2010-കളുടെ ആരംഭത്തിൽ, ഇത് വെബ് APIs, കോൺഫിഗറേഷൻ ഫയലുകൾ, NoSQL ഡാറ്റാബേസുകളിൽ ഡാറ്റാ സംഭരണത്തിനായി ഡിഫാക്ടോ സ്റ്റാൻഡേർഡ് ആയി മാറി, ഉദാ: MongoDB, CouchDB.
ഇന്ന്, JSON prácticamente എല്ലാ പ്രോഗ്രാമിംഗ് ഭാഷകളാൽ പിന്തുണയ്ക്കുന്നു, വെബ് ആപ്ലിക്കേഷനുകളിൽ അനവധി ഉപയോഗിക്കുന്നു. അതിന്റെ സിമ്പ്ലിസിറ്റിയും, ഫ്ലെക്സിബിലിറ്റിയും, സർവ്വവ്യാപകമായ പിന്തുണയും കാരണം, ഇത് ആധുനിക കംപ്യൂട്ടിങ്ങിൽ ഏറ്റവും പ്രധാനപ്പെട്ട ഡാറ്റാ ഫോർമാറ്റുകളിൽ ഒന്നായി മാറിയിട്ടുണ്ട്.
ഇവിടെ വിവിധ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ 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));
141# 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))
141// 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}
221// 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);
131# 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)
161// 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}
261// 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}
28JSON ഫോർമാറ്റിംഗ് ചെയ്യുമ്പോൾ, ഈ സാധ്യതയുള്ള വെല്ലുവിളികൾക്കായി ജാഗ്രത പുലർത്തുക:
വളരെ വലിയ JSON ഫയലുകൾ (ചില മേഘങ്ങൾ അല്ലെങ്കിൽ കൂടുതൽ) ബ്രൗസർ അടിസ്ഥാന ഫോർമാറ്ററുകളിൽ പ്രവർത്തന പ്രശ്നങ്ങൾ ഉണ്ടാക്കാം. ഇത്തരം കേസുകളിൽ:
jqഅത്യന്തം നസ്ട് JSON (10-20 ലെവലുകൾക്കുപരം) ഫോർമാറ്റുചെയ്യുമ്പോൾ പോലും നാവിഗേറ്റ് ചെയ്യാൻ ബുദ്ധിമുട്ടായേക്കാം. ഈ സാഹചര്യങ്ങളിൽ:
JSON യൂണികോഡ് പിന്തുണയ്ക്കുന്നു, എന്നാൽ ചില ഫോർമാറ്ററുകൾക്ക് ചില അക്ഷരങ്ങളുമായി പ്രശ്നങ്ങൾ ഉണ്ടാകാം:
JSON സംഖ്യകളുടെ കൃത്യത വ്യക്തമാക്കുന്നില്ല, ഇത് വളരെ വലിയ ഇന്റേജറുകൾ അല്ലെങ്കിൽ ഫ്ലോട്ടിംഗ്-പോയിന്റ് മൂല്യങ്ങൾക്കൊപ്പം പ്രശ്നങ്ങൾ ഉണ്ടാക്കാം:
സാധുവായ JSON ശൂന്യമായ ഒബ്ജക്റ്റുകൾ {}-യും അറേകൾ []-യും ഉൾക്കൊള്ളുന്നു, ഇത് ശരിയായ രീതിയിൽ ഫോർമാറ്റ് ചെയ്യണം:
{} എന്ന രൂപത്തിൽ കാണപ്പെടണം[] എന്ന രൂപത്തിൽ കാണപ്പെടണംനിങ്ങളുടെ പ്രവർത്തനത്തിന് ഉപയോഗപ്പെടുന്ന കൂടുതൽ ഉപകരണങ്ങൾ കണ്ടെത്തുക.