Formatera och snygga till din JSON-data med korrekt indragning. Gör rå JSON läsbar med syntaxmarkering och validering.
Formatera och försköna din JSON med detta enkla verktyg
Formaterad JSON kommer att visas här...
JSON (JavaScript Object Notation) är ett lättviktigt datautbytesformat som har blivit standard för datautbyte i webbapplikationer. Trots sin enkelhet kan JSON-data bli svåra att läsa när de är minifierade eller saknar korrekt formatering. Det här verktyget hjälper dig att omvandla råa, oformaterade JSON-strängar till ett välstrukturerat, indenterat format som är mycket lättare att läsa och analysera.
JSON-formatering (även känd som "pretty printing") lägger till konsekvent indragning, radbrytningar och mellanrum för att göra den hierarkiska strukturen av JSON-data visuellt tydlig. Detta är särskilt värdefullt när man arbetar med komplexa nästlade objekt eller stora dataset där relationerna mellan elementen annars kan vara svåra att urskilja.
Vårt JSON-formateringsverktyg erbjuder ett enkelt gränssnitt för att försköna din JSON-data med korrekt indragning och struktur, vilket gör den mer läsbar för människor samtidigt som den behåller sin giltighet för maskiner.
JSON bygger på två primära strukturer:
{}. Varje namn följs av ett kolon : och par separeras med kommatecken ,.1 {"name": "John", "age": 30, "city": "New York"}
2 []. Värden separeras med kommatecken ,.1 ["apple", "banana", "cherry"]
2 JSON-värden kan vara:
"Hello World"42 eller 3.14159true eller falsenull{"key": "value"}[1, 2, 3]Korrekt JSON måste följa dessa syntaxregler:
Vanliga syntaxfel inkluderar:
JSON-formatering omvandlar kompakt, minifierad JSON till en mer läsbar form genom att:
Parsa: JSON-strängen parsas först för att säkerställa att den är giltig och för att skapa en minnesrepresentation av datastrukturen.
Indragning: Varje nästlad nivå av objekt och arrayer indras (vanligtvis med 2 eller 4 mellanslag) för att visuellt representera hierarkin.
Radbrytningar: Nya rader läggs till efter varje egenskap eller arrayelement för att förbättra läsbarheten.
Mellanrum: Konsekventa mellanrum läggs till runt kolon och kommatecken.
Till exempel, denna minifierade JSON:
1{"name":"John Doe","age":30,"address":{"street":"123 Main St","city":"Anytown","state":"CA"},"hobbies":["reading","hiking","photography"]}
2Blir denna formaterade 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}
15Vår formaterare använder en standardindragning på 2 mellanslag per nivå, vilket är en vanlig konvention i utvecklingsgemenskapen och ger en bra balans mellan kompakthet och läsbarhet.
En kritisk aspekt av JSON-formatering är validering. Innan JSON kan formateras måste den vara syntaktiskt giltig enligt JSON-specifikationen. Vanliga valideringsfel inkluderar:
Syntaxfel:
Datatypfel:
undefined eller NaNNär du stöter på ogiltig JSON kan felmeddelandet hjälpa till att identifiera problemet. De flesta JSON-parsare kommer att ange den position där parsningen misslyckades, vilket kan hjälpa till att lokalisera problemet. Vårt verktyg ger tydliga felmeddelanden för att hjälpa dig att identifiera och åtgärda problem i din JSON-data.
JSON-formatering är värdefull i många scenarier:
När du arbetar med RESTful API:er gör formaterad JSON det lättare att:
Många moderna applikationer använder JSON för konfiguration:
Formaterad JSON hjälper när:
Korrekt formaterad JSON är avgörande när:
Tydlig JSON-formatering är värdefull för:
Även om vårt webbaserade JSON-formateringsverktyg är praktiskt för snabba formateringsuppgifter, finns det flera alternativ för olika scenarier:
Moderna webbläsare inkluderar JSON-formateringsfunktioner:
De flesta utvecklingsmiljöer erbjuder JSON-formatering:
För terminalanvändare eller automatisering:
jq är en kraftfull kommandoradsprocessor för JSONjson_pp finns förinstallerad på många Unix-systempython -m json.tool ger snabb formatering med PythonNär du formaterar JSON inom applikationer:
1// JavaScript
2const formatted = JSON.stringify(jsonObject, null, 2);
31# Python
2import json
3formatted = json.dumps(json_object, indent=2)
41// Java med 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 skapades av Douglas Crockford i början av 2000-talet som ett lättviktigt alternativ till XML. Formatet härstammar från JavaScript-objektets litterala syntax men är utformat för att vara oberoende av språk. År 2006 specificerades JSON formellt i RFC 4627, och det fick snabbt popularitet på grund av sin enkelhet och kompatibilitet med JavaScript.
Innan JSON var XML det dominerande formatet för datautbyte, men dess verbositet och komplexitet gjorde det besvärligt för många applikationer. JSON erbjöd en mer koncis syntax som var lättare att läsa och skriva, både för människor och maskiner. Det passade också perfekt med JavaScripts objektmodell, vilket gjorde det till det naturliga valet för webbapplikationer.
JSON:s antagande accelererade med uppkomsten av AJAX och RESTful API:er i mitten av 2000-talet. Vid 2010-talet hade det blivit standardformatet för webb-API:er, konfigurationsfiler och datalagring i NoSQL-databaser som MongoDB och CouchDB.
Idag stöds JSON av praktiskt taget alla programmeringsspråk och används i otaliga applikationer över hela webben. Dess enkelhet, flexibilitet och universella stöd har gjort det till ett av de viktigaste dataformaterna i modern databehandling.
Här är exempel på hur man formaterar JSON i olika programmeringsspråk:
1// JavaScript JSON-formatering
2function formatJSON(jsonString) {
3 try {
4 const parsedData = JSON.parse(jsonString);
5 return JSON.stringify(parsedData, null, 2);
6 } catch (error) {
7 return `Fel: ${error.message}`;
8 }
9}
10
11// Exempelanvändning
12const rawJSON = '{"name":"John","age":30,"city":"New York"}';
13console.log(formatJSON(rawJSON));
141# Python JSON-formatering
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"Fel: {str(e)}"
10
11# Exempelanvändning
12raw_json = '{"name":"John","age":30,"city":"New York"}'
13print(format_json(raw_json))
141// Java JSON-formatering med 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 "Fel: " + 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-formatering
2function formatJSON($jsonString) {
3 $result = json_decode($jsonString);
4 if (json_last_error() !== JSON_ERROR_NONE) {
5 return "Fel: " . json_last_error_msg();
6 }
7 return json_encode($result, JSON_PRETTY_PRINT);
8}
9
10// Exempelanvändning
11$rawJSON = '{"name":"John","age":30,"city":"New York"}';
12echo formatJSON($rawJSON);
131# Ruby JSON-formatering
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 "Fel: #{e.message}"
10 end
11end
12
13# Exempelanvändning
14raw_json = '{"name":"John","age":30,"city":"New York"}'
15puts format_json(raw_json)
161// C# JSON-formatering med 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 $"Fel: {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-formatering
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("Fel: %s", err.Error())
14 }
15
16 formattedBytes, err := json.MarshalIndent(parsedData, "", " ")
17 if err != nil {
18 return fmt.Sprintf("Fel: %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}
28När du arbetar med JSON-formatering, var medveten om dessa potentiella utmaningar:
Mycket stora JSON-filer (flera megabyte eller mer) kan orsaka prestandaproblem i webbläsarbaserade formaterare. För sådana fall:
jqExtremt nästlad JSON (mer än 10-20 nivåer djup) kan bli svår att navigera även när den är formaterad. I dessa fall:
JSON stöder Unicode, men vissa formaterare kan ha problem med vissa tecken:
JSON specificerar inte precision för tal, vilket kan leda till problem med mycket stora heltal eller flyttal:
Giltig JSON inkluderar tomma objekt {} och arrayer [], som bör formateras korrekt:
{}[]Upptäck fler verktyg som kan vara användbara för din arbetsflöde