JSON-formatter

Hvad er JSON-formatering?

JSON-formatering er processen med at konvertere JSON-data til en konsekvent, menneskeligt læsbar form ved at tilføje indrykninger, mellemrum og linjeskift—uden at ændre struktur eller indhold. Korrekt formatering gør JSON nemmere at inspicere, fejlfinde, dele og redigere, samtidig med at det forbliver kompatibelt med maskiner og softwareværktøjer.

JSON overser per definition mellemrum uden for tekstværdier. Dog kan dårligt formateret (eller minificeret) JSON—uden indrykninger eller samlet på en enkelt linje—være næsten umuligt for mennesker at læse eller pålideligt ændre.

Formatering vs. Minificering af JSON

• Formatering tilføjer mellemrum, indrykninger og linjeskift for klarhed og læsbarhed.
• Minificering fjerner al unødvendig mellemrum for maksimal kompakthed og effektivitet i lagring eller overførsel.
• Et robust JSON-formateringsværktøj giver dig mulighed for at skifte mellem disse tilstande, så du nemt kan gå fra menneskevenlige til maskineoptimerede versioner efter behov.

Eksempel: Minificeret vs. Formateret 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
}

Hvorfor formatere JSON?

• Læsbarhed: Korrekt indrykninger og linjeskift gør det lettere at gennemgå indlejrede objekter, opdage fejl og forstå komplekse datastrukturer med et enkelt blik.
• Fejlsøgning: Det er langt enklere at finde og rette ugyldige eller uventede data, når du visuelt kan scanne og spore nøgler, værdier og indlejringsniveauer.
• Samarbejde: Velstruktureret JSON er nemmere at gennemgå, diskutere og redigere ved kodegennemgange, dokumentation eller delte filer.
• Versionskontrol: Git og andre VCS-værktøjer giver mere meningsfulde forskelle med formateret JSON, hvilket gør det lettere at følge ændringer over tid.
• Overensstemmelse: Mange stilmanualer og automatiske linters (f.eks. Prettier, ESLint eller jq) håndhæver konsekvent formatering for klarhed og standardisering.
• Værktøjskompatibilitet: Nogle API'er, CLI'er og editorer forventer formateret input for nemmere menneskelig interaktion eller logning.

Hvordan fungerer en JSON-formatter?

1. Parsing: Formatteren forsøger først at analysere din inputtekst med en streng JSON-parser. Dette trin tjekker for syntaksvaliditet — fanger problemer som manglende anførselstegn, afsluttende kommaer eller ikke-escaped tegn.
2. Pæn-udskrift: Når det er gyldigt, serialiseres de parserede data tilbage til en tekststreng med brugerdefineret indrykning (typisk 2 eller 4 mellemrum) og linjeskift, hvilket skaber en "pæn-udskrevet" version.

Hvis input ikke er gyldigt JSON, kaster formatteren en fejl eller leverer en hjælpsom besked, der angiver placering og art af problemet.

Formateringsmuligheder

• Indrykning: Indstil antal mellemrum pr. niveau (op til 8).
• Sorter objektnøgler alfabetisk
• Brug tabulatorer til indrykning i stedet for mellemrum
• Escape ikke-ASCII tegn som Unicode
• Minificér output (én linje, uden mellemrum)

Almindelige problemer løst ved formatering

• Én-linje/minificeret JSON: Data fra API'er eller logfiler er ofte minificeret for båndbreddeeffektivitet, hvilket gør manuel redigering svær. Formatering genskaber læsbarheden for gennemgang og redigering.
• Inkonsekvent indrykning: JSON fra forskellige kilder kan indeholde blanding af tabulatorer, mellemrum eller ujævn indrykningsdybde. Omlægning harmoniserer disse forskelle og forbedrer klarhed og konsistens.
• Store/indlejrede strukturer: Dybt indlejrede arrays eller objekter (som konfigurationsfiler eller komplekse API-svar) bliver håndterbare og nemme at navigere, når de formateres med kollapsbare visninger i understøttede editorer.

Virkeligt eksempel: Formatering af API-responser

Ved integration med tredjeparts-API'er (som AWS, Stripe eller Google Cloud) komprimeres svar ofte for hastighed. Formatering af JSON-output gør det lettere at inspicere manglende felter, fejlfinde uventede værdier eller dele med kolleger.

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

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

Sådan formaterer du JSON med dette værktøj

1. Indsæt eller upload dit rå, minificerede eller dårligt formaterede JSON i inputfeltet.
2. Vælg formateringsmuligheder (indrykningsstørrelse, sortering af nøgler osv.).
3. Klik på "Formater" for at behandle din input.
4. Se eller kopier det rene og læselige output. Ved fejl vises detaljerede syntaksbeskeder for at hjælpe dig med at rette JSON.

Alt formatering foregår sikkert i din browser — dine data forlader aldrig din enhed.

Kodeeksempler til JSON-formatering

Se, hvordan du formaterer JSON i forskellige programmeringssprog. Disse eksempler illustrerer grundlæggende formateringsteknikker.

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)
}