Formater og pynt JSON-dataene dine med riktig innrykk. Gjør rå JSON lesbart med syntaksutheving og validering.
Formater og vakre JSON med dette enkle verktøyet
Formatert JSON vil vises her...
JSON (JavaScript Object Notation) er et lettvekts datautvekslingsformat som har blitt standarden for datautveksling i webapplikasjoner. Til tross for sin enkelhet kan JSON-data bli vanskelig å lese når det er minifisert eller mangler riktig formatering. Dette verktøyet hjelper deg med å transformere rå, uformaterte JSON-strenger til et godt strukturert, innrykket format som er mye lettere å lese og analysere.
JSON-formatering (også kjent som "pretty printing") legger til konsekvent innrykk, linjeskift og mellomrom for å gjøre den hierarkiske strukturen av JSON-data visuelt tydelig. Dette er spesielt verdifullt når man arbeider med komplekse nestede objekter eller store datasett der forholdet mellom elementene ellers kan være vanskelig å oppdage.
Vårt JSON-formateringsverktøy gir et enkelt grensesnitt for å gjøre JSON-data mer lesbare med riktig innrykk og struktur, noe som gjør det mer lesbart for mennesker samtidig som det opprettholder gyldigheten for maskiner.
JSON er bygget på to primære strukturer:
{}. Hvert navn etterfølges av et kolon : og parene separeres med kommaer ,.1 {"name": "John", "age": 30, "city": "New York"}
2 []. Verdiene separeres med kommaer ,.1 ["apple", "banana", "cherry"]
2 JSON-verdier kan være:
"Hello World"42 eller 3.14159true eller falsenull{"key": "value"}[1, 2, 3]Korrekt JSON må følge disse syntaksreglene:
Vanlige syntaksfeil inkluderer:
JSON-formatering transformerer kompakt, minifisert JSON til en mer lesbar form ved å:
Parsing: JSON-strengen blir først analysert for å sikre at den er gyldig og for å lage en minnebasert representasjon av datastrukturen.
Innrykk: Hvert nestede nivå av objekter og arrays blir innrykket (vanligvis med 2 eller 4 mellomrom) for å visuelt representere hierarkiet.
Linjeskift: Nye linjer legges til etter hver egenskap eller array-element for å forbedre lesbarheten.
Mellomrom: Konsistent mellomrom legges til rundt koloner og kommaer.
For eksempel, denne minifiserte JSON:
1{"name":"John Doe","age":30,"address":{"street":"123 Main St","city":"Anytown","state":"CA"},"hobbies":["reading","hiking","photography"]}
2Blir denne formaterte 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 formaterer bruker en standardinnrykk på 2 mellomrom per nivå, som er en vanlig konvensjon i utviklingssamfunnet og gir en god balanse mellom kompakthet og lesbarhet.
Et kritisk aspekt ved JSON-formatering er validering. Før JSON kan formateres, må den være syntaktisk gyldig i henhold til JSON-spesifikasjonen. Vanlige valideringsfeil inkluderer:
Syntaksfeil:
Datatypefeil:
undefined eller NaNNår du møter ugyldig JSON, kan feilmeldingen hjelpe deg med å identifisere problemet. De fleste JSON-parsere vil indikere posisjonen der parsing feilet, noe som kan hjelpe med å lokalisere problemet. Vårt verktøy gir klare feilmeldinger for å hjelpe deg med å identifisere og fikse problemer i JSON-dataene dine.
JSON-formatering er verdifull i mange scenarier:
Når du arbeider med RESTful API-er, gjør formatert JSON det lettere å:
Mange moderne applikasjoner bruker JSON for konfigurasjon:
Formatert JSON hjelper når:
Korrekt formatert JSON er viktig når:
Klar JSON-formatering er verdifull for:
Selv om vårt nettbaserte JSON-formateringsverktøy er praktisk for raske formateringsoppgaver, finnes det flere alternativer for forskjellige scenarier:
Moderne nettlesere inkluderer JSON-formateringsmuligheter:
De fleste utviklingsmiljøer tilbyr JSON-formatering:
For terminalbrukere eller automatisering:
jq er en kraftig kommandolinje JSON-prosessorjson_pp følger med på mange Unix-systemerpython -m json.tool gir rask formatering ved hjelp av PythonNår du formaterer JSON i applikasjoner:
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 ble laget av Douglas Crockford på begynnelsen av 2000-tallet som et lettvekts alternativ til XML. Formatet ble avledet fra JavaScript-objektlitteralsyntaks, men designet for å være språk-uavhengig. I 2006 ble JSON formelt spesifisert i RFC 4627, og det fikk raskt popularitet på grunn av sin enkelhet og kompatibilitet med JavaScript.
Før JSON var XML det dominerende formatet for datautveksling, men dens verbositet og kompleksitet gjorde det tungvint for mange applikasjoner. JSON tilbød en mer konsis syntaks som var lettere å lese og skrive, både for mennesker og maskiner. Det passet også perfekt med JavaScripts objektmodell, noe som gjorde det til det naturlige valget for webapplikasjoner.
JSONs adopsjon akselererte med fremveksten av AJAX og RESTful API-er på midten av 2000-tallet. Innen 2010-årene hadde det blitt den de facto standarden for web-API-er, konfigurasjonsfiler og datalagring i NoSQL-databaser som MongoDB og CouchDB.
I dag støttes JSON av praktisk talt hvert programmeringsspråk og brukes i utallige applikasjoner på nettet. Dets enkelhet, fleksibilitet og universelle støtte har gjort det til et av de viktigste dataformatene i moderne databehandling.
Her er eksempler på hvordan man kan formatere JSON i ulike 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 `Error: ${error.message}`;
8 }
9}
10
11// Eksempel på bruk
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"Error: {str(e)}"
10
11# Eksempel på bruk
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 "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-formatering
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// Eksempel på bruk
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 "Error: #{e.message}"
10 end
11end
12
13# Eksempel på bruk
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 $"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-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("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}
28Når man arbeider med JSON-formatering, vær oppmerksom på disse potensielle utfordringene:
Veldig store JSON-filer (flere megabyte eller mer) kan forårsake ytelsesproblemer i nettleserbaserte formaterere. For slike tilfeller:
jqEkstremt nestede JSON (mer enn 10-20 nivåer dypt) kan bli vanskelig å navigere selv når de er formatert. I slike tilfeller:
JSON støtter Unicode, men noen formaterere kan ha problemer med visse tegn:
JSON spesifiserer ikke presisjon for tall, noe som kan føre til problemer med veldig store heltall eller flyttall:
Gyldig JSON inkluderer tomme objekter {} og arrays [], som skal formateres riktig:
{}[]Oppdag flere verktøy som kan være nyttige for arbeidsflyten din