Formatirajte i uljepšajte svoje JSON podatke s pravilnom uvlakom. Čini sirove JSON podatke čitljivima uz isticanje sintakse i validaciju.
Formatirajte i uljepšajte svoj JSON s ovim jednostavnim alatom
Formatirani JSON će se ovdje pojaviti...
JSON (JavaScript Object Notation) je lagani format za razmjenu podataka koji je postao standard za razmjenu podataka u web aplikacijama. Unatoč svojoj jednostavnosti, JSON podaci mogu postati teški za čitanje kada su minificirani ili nemaju odgovarajuće formatiranje. Ovaj alat pomaže vam da sirovi, neformatirani JSON nizovi postanu dobro strukturirani, uvučeni format koji je mnogo lakši za čitanje i analizu.
Formatiranje JSON-a (također poznato kao "lijepo ispisivanje") dodaje dosljednu uvučenost, prekide linija i razmake kako bi vizualno prikazalo hijerarhijsku strukturu JSON podataka. Ovo je posebno vrijedno kada radite s složenim ugniježdenim objektima ili velikim skupovima podataka gdje bi inače mogla biti teška za uočavanje odnosa između elemenata.
Naš alat za formatiranje JSON-a pruža jednostavno sučelje za uljepšavanje vaših JSON podataka s odgovarajućom uvučenošću i strukturom, čineći ih čitljivijima za ljude, dok zadržava svoju valjanost za strojeve.
JSON se temelji na dvije osnovne strukture:
{}. Svako ime slijedi dvotočka : i parovi su odvojeni zarezima ,.1 {"ime": "John", "dob": 30, "grad": "New York"}
2 []. Vrijednosti su odvojene zarezima ,.1 ["jabuka", "banana", "trešnja"]
2 JSON vrijednosti mogu biti:
"Pozdrav svijete"42 ili 3.14159true ili falsenull{"ključ": "vrijednost"}[1, 2, 3]Ispravan JSON mora slijediti ova pravila sintakse:
Uobičajene sintaktičke greške uključuju:
Formatiranje JSON-a transformira kompaktni, minificirani JSON u čitljiviji oblik tako da:
Parsira: JSON niz se prvo parsira kako bi se osiguralo da je valjan i kako bi se stvorila reprezentacija podataka u memoriji.
Uvučenost: Svaka ugniježđena razina objekata i nizova se uvuče (obično za 2 ili 4 razmaka) kako bi se vizualno prikazala hijerarhija.
Prekidi linija: Novi redovi se dodaju nakon svake imovine ili elementa niza kako bi se poboljšala čitljivost.
Razmaci: Dosljedni razmaci se dodaju oko dvotočaka i zareza.
Na primjer, ovaj minificirani JSON:
1{"ime":"John Doe","dob":30,"adresa":{"ulica":"123 Main St","grad":"Anytown","država":"CA"},"hobi":["čitanje","planinarenje","fotografija"]}
2Postaje ovaj formatirani JSON:
1{
2 "ime": "John Doe",
3 "dob": 30,
4 "adresa": {
5 "ulica": "123 Main St",
6 "grad": "Anytown",
7 "država": "CA"
8 },
9 "hobi": [
10 "čitanje",
11 "planinarenje",
12 "fotografija"
13 ]
14}
15Naš formatator koristi standardnu uvučenost od 2 razmaka po razini, što je uobičajena konvencija u razvoju i pruža dobar balans između kompaktnosti i čitljivosti.
Kritični aspekt formatiranja JSON-a je validacija. Prije nego što se JSON može formatirati, mora biti sintaktički valjan prema JSON specifikaciji. Uobičajene greške u validaciji uključuju:
Sintaktičke greške:
Greške tipa podataka:
neodređeno ili NaNKada naiđete na nevaljan JSON, poruka o grešci može pomoći u identificiranju problema. Većina JSON parsera će ukazati na poziciju gdje je parsiranje neuspjelo, što može pomoći u lociranju problema. Naš alat pruža jasne poruke o grešci kako bi vam pomogao identificirati i ispraviti probleme u vašim JSON podacima.
Formatiranje JSON-a je vrijedno u brojnim scenarijima:
Kada radite s RESTful API-jima, formatirani JSON olakšava:
Mnoge moderne aplikacije koriste JSON za konfiguraciju:
Formatirani JSON pomaže kada:
Ispravno formatirani JSON je bitan kada:
Jasno formatiranje JSON-a je vrijedno za:
Iako je naš web-bazirani formatator JSON-a prikladan za brze zadatke formatiranja, postoje brojne alternative za različite scenarije:
Moderne preglednike uključuju mogućnosti formatiranja JSON-a:
Većina razvojnih okruženja nudi formatiranje JSON-a:
Za korisnike terminala ili automatizaciju:
jq je moćan alat za obradu JSON-a putem naredbenog retkajson_pp dolazi unaprijed instaliran na mnogim Unix sustavimapython -m json.tool pruža brzo formatiranje koristeći PythonKada formatirate JSON unutar aplikacija:
1// JavaScript
2const formatted = JSON.stringify(jsonObject, null, 2);
31# Python
2import json
3formatted = json.dumps(json_object, indent=2)
41// Java s 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 je stvorio Douglas Crockford ranih 2000-ih kao laganu alternativu XML-u. Format je proizašao iz sintakse JavaScript objektnog literala, ali je dizajniran da bude neovisan o jeziku. Godine 2006. JSON je službeno specificiran u RFC 4627, a brzo je stekao popularnost zbog svoje jednostavnosti i kompatibilnosti s JavaScript-om.
Prije JSON-a, XML je bio dominantni format za razmjenu podataka, ali je njegova opsežnost i složenost učinila ga nezgrapnim za mnoge aplikacije. JSON je ponudio sažetiju sintaksu koja je bila lakša za čitanje i pisanje, kako za ljude tako i za strojeve. Također se savršeno uklopio u objektni model JavaScript-a, čineći ga prirodnim izborom za web aplikacije.
Usvajanje JSON-a ubrzalo je s porastom AJAX-a i RESTful API-ja sredinom 2000-ih. Do 2010-ih, postao je de facto standard za web API-je, datoteke konfiguracija i pohranu podataka u NoSQL bazama podataka poput MongoDB i CouchDB.
Danas, JSON podržava gotovo svaki programski jezik i koristi se u bezbroj aplikacija širom weba. Njegova jednostavnost, fleksibilnost i univerzalna podrška učinili su ga jednim od najvažnijih formata podataka u modernom računalstvu.
Evo primjera kako formatirati JSON u raznim programskim jezicima:
1// JavaScript formatiranje JSON-a
2function formatJSON(jsonString) {
3 try {
4 const parsedData = JSON.parse(jsonString);
5 return JSON.stringify(parsedData, null, 2);
6 } catch (error) {
7 return `Greška: ${error.message}`;
8 }
9}
10
11// Primjer korištenja
12const rawJSON = '{"ime":"John","dob":30,"grad":"New York"}';
13console.log(formatJSON(rawJSON));
141# Python formatiranje JSON-a
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"Greška: {str(e)}"
10
11# Primjer korištenja
12raw_json = '{"ime":"John","dob":30,"grad":"New York"}'
13print(format_json(raw_json))
141// Java formatiranje JSON-a s 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 "Greška: " + e.getMessage();
14 }
15 }
16
17 public static void main(String[] args) {
18 String rawJSON = "{\"ime\":\"John\",\"dob\":30,\"grad\":\"New York\"}";
19 System.out.println(formatJSON(rawJSON));
20 }
21}
221// PHP formatiranje JSON-a
2function formatJSON($jsonString) {
3 $result = json_decode($jsonString);
4 if (json_last_error() !== JSON_ERROR_NONE) {
5 return "Greška: " . json_last_error_msg();
6 }
7 return json_encode($result, JSON_PRETTY_PRINT);
8}
9
10// Primjer korištenja
11$rawJSON = '{"ime":"John","dob":30,"grad":"New York"}';
12echo formatJSON($rawJSON);
131# Ruby formatiranje JSON-a
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 "Greška: #{e.message}"
10 end
11end
12
13# Primjer korištenja
14raw_json = '{"ime":"John","dob":30,"grad":"New York"}'
15puts format_json(raw_json)
161// C# formatiranje JSON-a s 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 $"Greška: {e.Message}";
17 }
18 }
19
20 static void Main()
21 {
22 string rawJSON = "{\"ime\":\"John\",\"dob\":30,\"grad\":\"New York\"}";
23 Console.WriteLine(FormatJSON(rawJSON));
24 }
25}
261// Go formatiranje JSON-a
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("Greška: %s", err.Error())
14 }
15
16 formattedBytes, err := json.MarshalIndent(parsedData, "", " ")
17 if err != nil {
18 return fmt.Sprintf("Greška: %s", err.Error())
19 }
20
21 return string(formattedBytes)
22}
23
24func main() {
25 rawJSON := `{"ime":"John","dob":30,"grad":"New York"}`
26 fmt.Println(formatJSON(rawJSON))
27}
28Kada radite s formatiranjem JSON-a, budite svjesni ovih potencijalnih izazova:
Vrlo velike JSON datoteke (nekoliko megabajta ili više) mogu uzrokovati probleme s performansama u formatatorima temeljenim na preglednicima. Za takve slučajeve:
jqEkstremno ugniježdeni JSON (više od 10-20 razina dubine) može postati teško navigirati čak i kada je formatiran. U tim slučajevima:
JSON podržava Unicode, ali neki formatatori mogu imati problema s određenim znakovima:
JSON ne specificira preciznost za brojeve, što može dovesti do problema s vrlo velikim cijelim brojevima ili brojevima s pomičnom točkom:
Valjan JSON uključuje prazne objekte {} i nizove [], koji bi trebali biti ispravno formatirani:
{}[]Otkrijte više alata koji bi mogli biti korisni za vaš radni proces