JSON Formatter

Was ist JSON-Formatierung?

JSON-Formatierung ist der Prozess, JSON-Daten in eine konsistente, für Menschen lesbare Darstellung zu transformieren, indem Einrückungen, Leerzeichen und Zeilenumbrüche hinzugefügt werden – ohne Struktur oder Inhalt zu verändern. Eine ordentliche Formatierung erleichtert das Überprüfen, Debuggen, Teilen und Bearbeiten von JSON und gewährleistet gleichzeitig die Kompatibilität mit Maschinen und Softwaretools.

JSON ignoriert per Definition Leerzeichen außerhalb von Zeichenketten. Schlecht formatiertes (oder minifiziertes) JSON – ohne Einrückungen oder auf eine einzige Zeile komprimiert – ist jedoch für Menschen kaum lesbar oder zuverlässig zu bearbeiten.

Formatieren vs. Minifizieren von JSON

• Formatieren fügt Leerzeichen, Einrückungen und Zeilenumbrüche für Klarheit und bessere Lesbarkeit hinzu.
• Minifizieren entfernt alle unnötigen Leerzeichen für maximale Kompaktheit und Effizienz bei Speicherung oder Übertragung.
• Ein ausgefeilter JSON-Formatter ermöglicht das einfache Umschalten zwischen beiden Modi, sodass Sie nach Bedarf zwischen menschenlesbaren und maschinenoptimierten Versionen wechseln können.

Beispiel: Minifiziertes vs. formatiertes JSON

{"id":"3f4b2c","user":{"name":"Dana","is_active":true},"roles":["admin","editor"],"count":7}

{
  "id": "3f4b2c",
  "user": {
    "name": "Dana",
    "is_active": true
  },
  "roles": [
    "admin",
    "editor"
  ],
  "count": 7
}

Warum JSON formatieren?

• Lesbarkeit: Richtige Einrückungen und Zeilenumbrüche erleichtern das Überprüfen verschachtelter Objekte, das Erkennen von Fehlern und das Verständnis komplexer Datenstrukturen auf einen Blick.
• Debugging: Fehlersuche bei ungültigen oder unerwarteten Daten wird deutlich einfacher, wenn Sie Schlüssel, Werte und Verschachtelung optisch erfassen und verfolgen können.
• Zusammenarbeit: Gut formatiertes JSON ist leichter zu überprüfen, zu diskutieren und bei Code-Reviews, Dokumentationen oder in gemeinsam genutzten Dateien zu bearbeiten.
• Versionsverwaltung: Git und andere Versionskontrollsysteme erzeugen aussagekräftigere Diffs mit formatiertem JSON, wodurch Änderungen im Zeitverlauf besser nachvollziehbar sind.
• Compliance: Viele Style-Guides und automatische Linter (wie Prettier, ESLint oder jq) verlangen konsistente Formatierung zur besseren Übersicht und Standardisierung.
• Tool-Kompatibilität: Einige APIs, CLI-Programme und Editoren erwarten formatierten Input für bessere menschliche Bedienbarkeit oder Logging.

Wie funktioniert ein JSON-Formatter?

1. Parsing: Zuerst versucht der Formatter, Ihren Eingabetext mit einem strengen JSON-Parser zu analysieren. Dabei wird die Syntax auf Gültigkeit geprüft – z. B. fehlende Anführungszeichen, abschließende Kommata oder nicht maskierte Zeichen werden erkannt.
2. Schönformatierung: Nach erfolgreicher Analyse wird die Datenstruktur mit benutzerdefinierter Einrückung (typischerweise 2 oder 4 Leerzeichen) und Zeilenumbrüchen wieder in einen String umgewandelt, wodurch eine „schönformatierte“ Version entsteht.

Ist die Eingabe kein gültiges JSON, zeigt der Formatter eine Fehlermeldung mit genauer Angabe der Art und Position des Problems an.

Formatierungsoptionen

• Einrückung: Legen Sie die Anzahl der Leerzeichen pro Ebene fest (bis zu 8).
• Objektschlüssel alphabetisch sortieren
• Tabs statt Leerzeichen für Einrückungen verwenden
• Nicht-ASCII-Zeichen als Unicode maskieren
• Ausgabe minifizieren (einzeilig, ohne Leerzeichen)

Häufige Probleme, die durch Formatierung gelöst werden

• Einzeiliges/Minifiziertes JSON: API-Antworten oder Logdateien sind oft minifiziert, um Bandbreite zu sparen, was manuelles Bearbeiten erschwert. Formatierung stellt die Lesbarkeit zur Überprüfung und Bearbeitung wieder her.
• Uneinheitliche Einrückung: JSON aus verschiedenen Quellen kann gemischte Tabs, Leerzeichen oder unterschiedliche Einrückungstiefen enthalten. Neu formatieren normalisiert diese Uneinheitlichkeiten für bessere Übersicht.
• Große/verschachtelte Strukturen: Tief verschachtelte Arrays oder Objekte (wie Konfigurationsdateien oder komplexe API-Antworten) werden durch Formatierung überschaubar und gut navigierbar, mit zusammenklappbaren Ansichten in unterstützten Editoren.

Praxisbeispiel: Formatierung von API-Antworten

Bei der Integration mit Drittanbieter-APIs (wie AWS, Stripe oder Google Cloud) sind die Antworten oft komprimiert für Geschwindigkeit. Formatiertes JSON erleichtert das Überprüfen fehlender Felder, das Debuggen unerwarteter Werte und das Teilen mit Kollegen.

{"amount":2500,"currency":"usd","status":"succeeded","charges":[{"id":"ch_1Gq","amount":2500}]}

{
  "amount": 2500,
  "currency": "usd",
  "status": "succeeded",
  "charges": [
    {
      "id": "ch_1Gq",
      "amount": 2500
    }
  ]
}

Wie verwende ich dieses Tool zum Formatieren von JSON?

1. Fügen Sie Ihre rohen, minifizierten oder schlecht formatierten JSON-Daten in das Eingabefeld ein oder laden Sie sie hoch.
2. Wählen Sie Formatierungsoptionen (Einrückungsgröße, Schlüssel sortieren usw.).
3. Klicken Sie auf „Formatieren“, um Ihre Daten zu verarbeiten.
4. Sehen Sie sich die saubere, lesbare Ausgabe an oder kopieren Sie sie. Bei Fehlern erscheinen detaillierte Syntaxmeldungen, die Ihnen beim Beheben helfen.

Alle Formatierungen erfolgen sicher in Ihrem Browser – Ihre Daten verlassen niemals Ihr Gerät.

Codebeispiele zur JSON-Formatierung

Sehen Sie, wie man JSON in verschiedenen Programmiersprachen formatiert. Diese Beispiele zeigen grundlegende Formatierungstechniken für JSON.

const ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
const pretty = JSON.stringify(JSON.parse(ugly), null, 2);
console.log(pretty);

import json
ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}'
pretty = json.dumps(json.loads(ugly), indent=2)
print(pretty)

package main
import (
  "encoding/json"
  "fmt"
)
func main() {
  ugly := []byte(`{"name":"Alice","age":30,"roles":["admin","user"]}`)
  var obj interface{}
  json.Unmarshal(ugly, &obj)
  pretty, _ := json.MarshalIndent(obj, "", "  ")
  fmt.Println(string(pretty))
}

import com.fasterxml.jackson.databind.ObjectMapper;
public class Main {
  public static void main(String[] args) throws Exception {
    String ugly = "{"name":"Alice","age":30,"roles":["admin","user"]}";
    ObjectMapper mapper = new ObjectMapper();
    Object obj = mapper.readValue(ugly, Object.class);
    String pretty = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
    System.out.println(pretty);
  }
}

using System;
using Newtonsoft.Json;
class Program {
  static void Main() {
    var ugly = "{"name":"Alice","age":30,"roles":["admin","user"]}";
    var parsed = JsonConvert.DeserializeObject(ugly);
    var pretty = JsonConvert.SerializeObject(parsed, Formatting.Indented);
    Console.WriteLine(pretty);
  }
}

<?php
$ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
$obj = json_decode($ugly);
echo json_encode($obj, JSON_PRETTY_PRINT);

require 'json'
ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}'
pretty = JSON.pretty_generate(JSON.parse(ugly))
puts pretty

echo '{"name":"Alice","age":30,"roles":["admin","user"]}' | jq .

fn main() {
  let ugly = r#"{"name":"Alice","age":30,"roles":["admin","user"]}"#;
  let value: serde_json::Value = serde_json::from_str(ugly).unwrap();
  let pretty = serde_json::to_string_pretty(&value).unwrap();
  println!("{}", pretty);
}

import com.fasterxml.jackson.databind.ObjectMapper
fun main() {
  val ugly = "{"name":"Alice","age":30,"roles":["admin","user"]}"
  val mapper = ObjectMapper()
  val obj = mapper.readValue(ugly, Any::class.java)
  val pretty = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj)
  println(pretty)
}

import Foundation
let ugly = "{\"name\":\"Alice\",\"age\":30,\"roles\":[\"admin\",\"user\"]}"
if let data = ugly.data(using: .utf8),
   let obj = try? JSONSerialization.jsonObject(with: data),
   let pretty = try? JSONSerialization.data(withJSONObject: obj, options: .prettyPrinted),
   let prettyString = String(data: pretty, encoding: .utf8) {
    print(prettyString)
}

const ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
const pretty = JSON.stringify(JSON.parse(ugly), null, 2);
console.log(pretty);

SELECT jsonb_pretty('{"name":"Alice","age":30,"roles":["admin","user"]}'::jsonb);

SELECT JSON_PRETTY('{"name":"Alice","age":30,"roles":["admin","user"]}');

$ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}'
$obj = $ugly | ConvertFrom-Json
$pretty = $obj | ConvertTo-Json -Depth 10
Write-Output $pretty

use JSON;
my $ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
my $obj = decode_json($ugly);
print to_json($obj, { pretty => 1 });

import 'dart:convert';
void main() {
  const ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
  final obj = jsonDecode(ugly);
  final pretty = JsonEncoder.withIndent('  ').convert(obj);
  print(pretty);
}

ugly = ~s({"name":"Alice","age":30,"roles":["admin","user"]})
{:ok, obj} = Jason.decode(ugly)
pretty = Jason.encode!(obj, pretty: true)
IO.puts(pretty)

import play.api.libs.json._
object Main extends App {
  val ugly = """{"name":"Alice","age":30,"roles":["admin","user"]}"""
  val jsValue = Json.parse(ugly)
  val pretty = Json.prettyPrint(jsValue)
  println(pretty)
}