Formatteer en verfraai uw JSON-gegevens met de juiste indentatie. Maakt ruwe JSON leesbaar met syntaxismarkering en validatie.
Formatteer en verfraai uw JSON met deze eenvoudige tool
Geformatteerde JSON verschijnt hier...
JSON (JavaScript Object Notation) is een lichtgewicht gegevensuitwisselingsformaat dat de standaard is geworden voor gegevensuitwisseling in webapplicaties. Ondanks zijn eenvoud kan JSON-gegevens moeilijk leesbaar worden wanneer het geminimaliseerd is of geen juiste opmaak heeft. Deze tool helpt je om ruwe, onopgemaakte JSON-strings om te zetten in een goed gestructureerd, ingesprongen formaat dat veel gemakkelijker te lezen en te analyseren is.
JSON-opmaak (ook wel "pretty printing" genoemd) voegt consistente inspringing, regelafbrekingen en spatiƫring toe om de hiƫrarchische structuur van JSON-gegevens visueel duidelijk te maken. Dit is vooral waardevol bij het werken met complexe geneste objecten of grote datasets waarbij de relaties tussen elementen anders moeilijk te onderscheiden zijn.
Onze JSON-opmaaktool biedt een eenvoudige interface om je JSON-gegevens te verfraaien met de juiste inspringing en structuur, waardoor het leesbaarder wordt voor mensen en tegelijkertijd geldig blijft voor machines.
JSON is opgebouwd uit twee primaire structuren:
{}. Elke naam wordt gevolgd door een dubbele punt : en paren worden gescheiden door komma's ,.1 {"naam": "John", "leeftijd": 30, "stad": "New York"}
2 []. Waarden worden gescheiden door komma's ,.1 ["appel", "banaan", "kers"]
2 JSON-waarden kunnen zijn:
"Hallo Wereld"42 of 3.14159waar of onwaarnull{"sleutel": "waarde"}[1, 2, 3]Juiste JSON moet voldoen aan deze syntaxisregels:
Veelvoorkomende syntaxisfouten zijn onder andere:
JSON-opmaak transformeert compacte, geminimaliseerde JSON in een leesbaardere vorm door:
Parseren: De JSON-string wordt eerst geparsed om te zorgen dat deze geldig is en om een in-memory representatie van de datastructuur te creƫren.
Inspringing: Elk genest niveau van objecten en arrays wordt ingesprongen (typisch met 2 of 4 spaties) om de hiƫrarchie visueel weer te geven.
Regelafbrekingen: Nieuwe regels worden toegevoegd na elke eigenschap of array-element om de leesbaarheid te verbeteren.
Spatiƫring: Consistente spatiƫring wordt toegevoegd rond dubbele punten en komma's.
Bijvoorbeeld, deze geminimaliseerde JSON:
1{"naam":"John Doe","leeftijd":30,"adres":{"straat":"123 Hoofdstraat","stad":"Anytown","staat":"CA"},"hobby's":["lezen","wandelen","fotografie"]}
2Wordt deze opgemaakte JSON:
1{
2 "naam": "John Doe",
3 "leeftijd": 30,
4 "adres": {
5 "straat": "123 Hoofdstraat",
6 "stad": "Anytown",
7 "staat": "CA"
8 },
9 "hobby's": [
10 "lezen",
11 "wandelen",
12 "fotografie"
13 ]
14}
15Onze formatter gebruikt een standaard inspringing van 2 spaties per niveau, wat een veelvoorkomende conventie is in de ontwikkelingsgemeenschap en een goede balans biedt tussen compactheid en leesbaarheid.
Een cruciaal aspect van JSON-opmaak is validatie. Voordat JSON kan worden opgemaakt, moet het syntactisch geldig zijn volgens de JSON-specificatie. Veelvoorkomende validatiefouten zijn onder andere:
Syntaxisfouten:
Gegevens typefouten:
undefined of NaNWanneer je te maken krijgt met ongeldige JSON, kan het foutbericht helpen om het probleem te identificeren. De meeste JSON-parsers geven de positie aan waar de parsing is mislukt, wat kan helpen om het probleem te lokaliseren. Onze tool biedt duidelijke foutmeldingen om je te helpen bij het identificeren en oplossen van problemen in je JSON-gegevens.
JSON-opmaak is waardevol in tal van scenario's:
Bij het werken met RESTful API's maakt opgemaakte JSON het gemakkelijker om:
Veel moderne applicaties gebruiken JSON voor configuratie:
Opgemaakte JSON helpt bij:
Juiste opgemaakte JSON is essentieel bij:
Duidelijke JSON-opmaak is waardevol voor:
Hoewel onze webgebaseerde JSON-opmaaktool handig is voor snelle opmaaktaken, bestaan er verschillende alternatieven voor verschillende scenario's:
Moderne browsers bevatten JSON-opmaakmogelijkheden:
De meeste ontwikkelomgevingen bieden JSON-opmaak:
Voor terminalgebruikers of automatisering:
jq is een krachtige commandoregel JSON-processorjson_pp wordt op veel Unix-systemen standaard meegeleverdpython -m json.tool biedt snelle opmaak met behulp van PythonBij het formatteren van JSON binnen applicaties:
1// JavaScript
2const formatted = JSON.stringify(jsonObject, null, 2);
31# Python
2import json
3formatted = json.dumps(json_object, indent=2)
41// Java met 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 werd in de vroege jaren 2000 gemaakt door Douglas Crockford als een lichtgewicht alternatief voor XML. Het formaat is afgeleid van de syntaxis van JavaScript-objectliteralen, maar is ontworpen om taalonafhankelijk te zijn. In 2006 werd JSON formeel gespecificeerd in RFC 4627, en het kreeg snel populariteit vanwege zijn eenvoud en compatibiliteit met JavaScript.
Voor JSON was XML het dominante formaat voor gegevensuitwisseling, maar de verbositeit en complexiteit ervan maakten het omslachtig voor veel toepassingen. JSON bood een beknoptere syntaxis die gemakkelijker te lezen en te schrijven was, zowel voor mensen als machines. Het paste ook perfect bij het objectmodel van JavaScript, waardoor het de natuurlijke keuze werd voor webapplicaties.
De adoptie van JSON versnelde met de opkomst van AJAX en RESTful API's in het midden van de jaren 2000. Tegen de jaren 2010 was het de facto standaard voor web-API's, configuratiebestanden en gegevensopslag in NoSQL-databases zoals MongoDB en CouchDB.
Vandaag de dag wordt JSON door vrijwel elke programmeertaal ondersteund en wordt het in talloze toepassingen op het web gebruikt. De eenvoud, flexibiliteit en universele ondersteuning hebben het tot een van de belangrijkste gegevensformaten in de moderne informatica gemaakt.
Hier zijn voorbeelden van hoe je JSON kunt formatteren in verschillende programmeertalen:
1// JavaScript JSON-opmaak
2function formatJSON(jsonString) {
3 try {
4 const parsedData = JSON.parse(jsonString);
5 return JSON.stringify(parsedData, null, 2);
6 } catch (error) {
7 return `Fout: ${error.message}`;
8 }
9}
10
11// Voorbeeld gebruik
12const rawJSON = '{"naam":"John","leeftijd":30,"stad":"New York"}';
13console.log(formatJSON(rawJSON));
141# Python JSON-opmaak
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"Fout: {str(e)}"
10
11# Voorbeeld gebruik
12raw_json = '{"naam":"John","leeftijd":30,"stad":"New York"}'
13print(format_json(raw_json))
141// Java JSON-opmaak met 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 "Fout: " + e.getMessage();
14 }
15 }
16
17 public static void main(String[] args) {
18 String rawJSON = "{\"naam\":\"John\",\"leeftijd\":30,\"stad\":\"New York\"}";
19 System.out.println(formatJSON(rawJSON));
20 }
21}
221// PHP JSON-opmaak
2function formatJSON($jsonString) {
3 $result = json_decode($jsonString);
4 if (json_last_error() !== JSON_ERROR_NONE) {
5 return "Fout: " . json_last_error_msg();
6 }
7 return json_encode($result, JSON_PRETTY_PRINT);
8}
9
10// Voorbeeld gebruik
11$rawJSON = '{"naam":"John","leeftijd":30,"stad":"New York"}';
12echo formatJSON($rawJSON);
131# Ruby JSON-opmaak
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 "Fout: #{e.message}"
10 end
11end
12
13# Voorbeeld gebruik
14raw_json = '{"naam":"John","leeftijd":30,"stad":"New York"}'
15puts format_json(raw_json)
161// C# JSON-opmaak met 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 $"Fout: {e.Message}";
17 }
18 }
19
20 static void Main()
21 {
22 string rawJSON = "{\"naam\":\"John\",\"leeftijd\":30,\"stad\":\"New York\"}";
23 Console.WriteLine(FormatJSON(rawJSON));
24 }
25}
261// Go JSON-opmaak
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("Fout: %s", err.Error())
14 }
15
16 formattedBytes, err := json.MarshalIndent(parsedData, "", " ")
17 if err != nil {
18 return fmt.Sprintf("Fout: %s", err.Error())
19 }
20
21 return string(formattedBytes)
22}
23
24func main() {
25 rawJSON := `{"naam":"John","leeftijd":30,"stad":"New York"}`
26 fmt.Println(formatJSON(rawJSON))
27}
28Bij het werken met JSON-opmaak, wees je bewust van deze potentiƫle uitdagingen:
Zeer grote JSON-bestanden (meerdere megabytes of meer) kunnen prestatieproblemen veroorzaken in browsergebaseerde formatters. Voor dergelijke gevallen:
jq te gebruikenExtreem geneste JSON (meer dan 10-20 niveaus diep) kan moeilijk te navigeren worden, zelfs wanneer het is opgemaakt. In deze gevallen:
JSON ondersteunt Unicode, maar sommige formatters kunnen problemen hebben met bepaalde tekens:
JSON specificeert geen precisie voor getallen, wat kan leiden tot problemen met zeer grote gehele getallen of drijvende-kommawaarden:
Geldige JSON omvat lege objecten {} en arrays [], die correct moeten worden opgemaakt:
{}[]Ontdek meer tools die handig kunnen zijn voor uw workflow