Formateur JSON

Qu'est-ce que le formatage JSON ?

Le formatage JSON est le processus qui transforme des données JSON en une représentation cohérente et lisible par l’homme en ajoutant indentations, espaces et sauts de ligne — sans modifier la structure ni le contenu. Un formatage adéquat facilite l’inspection, le débogage, le partage et l’édition tout en restant compatible avec les machines et les outils logiciels.

Par définition, JSON ignore les espaces hors des valeurs string. Cependant, un JSON mal formaté (ou minifié) — sans indentation ou tout en une seule ligne — peut être quasiment illisible ou difficile à modifier pour un humain.

Formatage vs minification du JSON

• Le formatage ajoute espaces, indentations et sauts de ligne pour plus de clarté et lisibilité.
• La minification supprime tous les espaces inutiles pour compacter au maximum et optimiser le stockage ou le transfert.
• Un formateur JSON performant permet de basculer facilement entre ces modes, offrant une version lisible par l’homme ou optimisée machine selon les besoins.

Exemple : JSON minifié vs formaté

{"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
}

Pourquoi formater le JSON ?

• Lisibilité : Une bonne indentation et des sauts de ligne facilitent l’inspection des objets imbriqués, la détection d’erreurs et la compréhension rapide de structures de données complexes.
• Débogage : Il est beaucoup plus simple de diagnostiquer des données invalides ou inattendues en visualisant clairement clés, valeurs et niveaux d’imbrication.
• Collaboration : Un JSON bien formaté est plus facile à relire, discuter et modifier lors de revues de code, dans la documentation ou les fichiers partagés.
• Gestion de versions : Git et autres outils VCS produisent des diff plus significatifs avec un JSON formaté, ce qui facilite le suivi des modifications dans le temps.
• Conformité : De nombreux guides de style et linters automatiques (comme Prettier, ESLint ou jq) imposent un formatage cohérent pour plus de clarté et d’uniformité.
• Compatibilité des outils : Certaines API, interfaces en ligne de commande et éditeurs attendent un JSON formaté pour une interaction humaine ou un journalisation facilités.

Comment marche un formateur JSON ?

1. Analyse : Le formateur tente d’abord de parser votre texte avec un parseur JSON strict. Cette étape vérifie la validité syntaxique — détectant par exemple des guillemets manquants, des virgules superflues ou des caractères non échappés.
2. Joli affichage : Si valide, les données parsées sont sérialisées en chaîne avec l’indentation choisie (souvent 2 ou 4 espaces) et des sauts de ligne, produisant une version "joliment imprimée".

Si l’entrée n’est pas un JSON valide, le formateur affiche une erreur ou un message utile indiquant la localisation et la nature du problème.

Options de formatage

• Indentation : Définissez le nombre d’espaces par niveau (jusqu’à 8).
• Trier les clés des objets par ordre alphabétique
• Utiliser des tabulations au lieu des espaces pour l’indentation
• Échapper les caractères non-ASCII en Unicode
• Minifier la sortie (ligne unique, sans espaces)

Problèmes courants résolus par le formatage

• JSON en une seule ligne/minifié : Les données renvoyées par des API ou fichiers logs sont souvent minifiées pour économiser la bande passante, rendant l’édition manuelle difficile. Le formatage restaure la lisibilité pour l’examen et la modification.
• Indentation incohérente : Le JSON copié depuis plusieurs sources peut mêler tabulations, espaces ou profondeurs inconsistantes. Le reformatage normalise ces différences, améliorant clarté et cohérence.
• Structures larges/imbriquées : Des tableaux ou objets profondément imbriqués (comme dans fichiers config ou réponses d’API complexes) deviennent maniables et faciles à naviguer une fois formatés, avec vues pliables dans les éditeurs compatibles.

Cas pratique : Formatage des réponses d’API

Lors d’intégrations avec des API tierces (AWS, Stripe, Google Cloud), les réponses sont souvent compactées pour la rapidité. Formater le JSON facilite l’inspection des champs manquants, le débogage des valeurs inattendues ou le partage avec l’équipe.

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

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

Comment formater du JSON avec cet outil

1. Collez ou importez votre JSON brut, minifié ou mal formaté dans la zone d’entrée.
2. Choisissez les options de formatage (taille d’indentation, tri des clés, etc.).
3. Cliquez sur "Formater" pour traiter votre saisie.
4. Visualisez ou copiez le résultat propre et lisible. En cas d’erreur, des messages syntaxiques détaillés vous aideront à corriger le JSON.

Toutes les opérations se font en toute sécurité dans votre navigateur — vos données ne quittent jamais votre appareil.

Exemples de code pour le formatage JSON

Découvrez comment formater du JSON dans différents langages de programmation. Ces exemples illustrent les techniques de formatage de base.

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