← Tous les articles
Mis à jour le May 29, 20268 min read

Comment formater du JSON : pretty-print, valider et nettoyer des fichiers JSON

Formatez du JSON avec JSON.stringify en JavaScript, json.dumps en Python, jq en ligne de commande ou instantanément dans votre navigateur. Inclut le tri des clés, la conversion YAML/CSV vers JSON et des exemples avant/après réels.

Le JSON brut d’une API ou d’un fichier de log arrive souvent sur une seule ligne ininterrompue —— valide, mais impossible à lire en un coup d’œil. Formatter le JSON (aussi appelé « pretty-print » ou « embellissement ») ajoute une indentation cohérente et des sauts de ligne pour que la structure devienne immédiatement claire. Ce guide montre comment formater un fichier ou une chaîne JSON en JavaScript, Python, en ligne de commande, et directement dans votre navigateur.

Que signifie « formater du JSON » ?

Un formateur JSON prend une chaîne JSON compacte ou mal indentée et la réécrit avec :

  • Chaque paire clé–valeur sur sa propre ligne
  • Les objets et tableaux imbriqués indentés d’un nombre fixe d’espaces (habituellement 2 ou 4)
  • Pas d’espaces en fin de ligne
// Avant formatage (minifié)
{"user":{"name":"Alice","age":30,"roles":["admin","editor"]}}

// Après formatage (indentation de 2 espaces)
{
  "user": {
    "name": "Alice",
    "age": 30,
    "roles": [
      "admin",
      "editor"
    ]
  }
}

Les deux formes sont sémantiquement identiques —— tout parseur JSON produit la même structure de données depuis l’une ou l’autre. Le formatage sert uniquement la lisibilité humaine.

Formater du JSON en JavaScript

JSON.stringify() accepte un deuxième argument (un replacer) et un troisième (le niveau d’indentation). Passez null comme replacer et 2 pour une indentation à 2 espaces (pour l’API complète, voir Comment Stringify du JSON) :

const obj = { user: { name: "Alice", age: 30, roles: ["admin", "editor"] } };

// Compact (sans formatage)
JSON.stringify(obj);

// Embelli avec indentation de 2 espaces
JSON.stringify(obj, null, 2);

// Indentation de 4 espaces
JSON.stringify(obj, null, 4);

// Indentation par tabulation
JSON.stringify(obj, null, '\t');

Formater une chaîne JSON (et non un objet)

Si vous avez une chaîne JSON déjà valide mais mal formatée, parsez d’abord puis re-stringify :

const raw = '{"name":"Alice","age":30}';
const formatted = JSON.stringify(JSON.parse(raw), null, 2);
console.log(formatted);

Trier les clés par ordre alphabétique

Pour trier les clés des objets pendant le formatage, passez une fonction replacer qui trie les clés de chaque objet rencontré :

function sortedStringify(obj, indent = 2) {
  return JSON.stringify(obj, (key, value) => {
    if (value && typeof value === 'object' && !Array.isArray(value)) {
      return Object.keys(value).sort().reduce((acc, k) => {
        acc[k] = value[k];
        return acc;
      }, {});
    }
    return value;
  }, indent);
}

Formater du JSON en Python

Le module json intégré à Python gère le formatage via le paramètre indent :

import json

# Formater un dict Python
data = {"user": {"name": "Alice", "age": 30, "roles": ["admin", "editor"]}}
formatted = json.dumps(data, indent=2)
print(formatted)

# Formater une chaîne JSON
raw = '{"name":"Alice","age":30}'
formatted = json.dumps(json.loads(raw), indent=2)

# Trier les clés
formatted = json.dumps(data, indent=2, sort_keys=True)

# Formater un fichier JSON
with open('input.json') as f:
    data = json.load(f)
with open('output.json', 'w') as f:
    json.dump(data, f, indent=2)

Formater un fichier JSON en ligne de commande

Avec jq (recommandé)

jq est le processeur JSON standard en ligne de commande. Il formate JSON par défaut :

# Embellir un fichier JSON
jq . input.json

# Embellir et sauvegarder vers un nouveau fichier
jq . input.json > output.json

# Formater une réponse curl
curl -s https://api.example.com/users | jq .

# Trier les clés
jq --sort-keys . input.json

Avec Python (aucune installation requise)

Le module json.tool de Python fonctionne comme formateur en ligne de commande sur tout système où Python est installé :

# Formater un fichier
python3 -m json.tool input.json

# Formater depuis stdin
echo '{"name":"Alice","age":30}' | python3 -m json.tool

# Trier les clés
python3 -m json.tool --sort-keys input.json

Avec Node.js

node -e "const fs=require('fs'); const d=JSON.parse(fs.readFileSync('input.json')); console.log(JSON.stringify(d,null,2))"

Convertir des données au format JSON

« Format to JSON » signifie souvent sérialiser des données d’un autre format —— un dict Python, un fichier CSV, une config YAML —— en JSON valide.

De YAML vers JSON

# Python
import yaml, json
with open('config.yaml') as f:
    data = yaml.safe_load(f)
print(json.dumps(data, indent=2))

Ou utilisez le convertisseur YAML vers JSON dans votre navigateur —— pas de code requis. Pour savoir quand choisir l’un ou l’autre, voir JSON vs YAML ; pour comprendre pourquoi YAML 1.2 est un sur-ensemble strict de JSON, voir Compatibilité YAML 1.2 et JSON.

De CSV vers JSON

import csv, json
with open('data.csv') as f:
    rows = list(csv.DictReader(f))
print(json.dumps(rows, indent=2))

Depuis un objet JavaScript

Les objets JavaScript ressemblent à JSON mais n’en sont pas —— ils peuvent avoir des clés sans guillemets, des chaînes en guillemets simples, des virgules finales et des commentaires. Collez un littéral d’objet JavaScript invalide dans JSON Fix pour le convertir automatiquement en JSON valide.

Formater le JSON dans votre éditeur (Prettier, VS Code, pre-commit)

Au quotidien, le meilleur moment pour formater du JSON est à la sauvegarde —— ainsi rien d’unformatté n’atterrit dans git ni dans une PR.

Prettier

# installer
npm i -D prettier

# formater sur place tous les .json (et fichiers source)
npx prettier --write "**/*.{json,jsonc}"

# vérifier seulement (CI-friendly, code non-zéro si quelque chose doit être formaté)
npx prettier --check "**/*.json"

Prettier gère JSON et JSONC nativement. Un .prettierrc de deux lignes comme { "tabWidth": 2 } suffit généralement.

VS Code —— Format on Save

Installez l’extension Prettier et ajoutez dans le settings.json de votre workspace :

{
  "editor.formatOnSave": true,
  "[json]":   { "editor.defaultFormatter": "esbenp.prettier-vscode" },
  "[jsonc]":  { "editor.defaultFormatter": "esbenp.prettier-vscode" }
}

Hook pre-commit

Pour empêcher tout JSON non formaté d’être commité, branchez lint-staged + husky :

// package.json
{
  "lint-staged": { "*.{json,jsonc}": "prettier --write" }
}

# installer le hook
npx husky add .husky/pre-commit "npx lint-staged"

Exemple de formatage JSON : avant / après

// Non formaté —— valide mais illisible
{"orders":[{"id":1001,"customer":{"name":"Alice"},"items":[{"sku":"A1","qty":2}]}]}

// Formaté
{
  "orders": [
    {
      "id": 1001,
      "customer": { "name": "Alice" },
      "items": [ { "sku": "A1", "qty": 2 } ]
    }
  ]
}

Questions fréquentes

Comment formater du JSON en JavaScript ?

Utilisez JSON.stringify(value, null, 2) —— le troisième argument définit l’indentation (2 espaces, 4 espaces ou '\t' pour la tabulation). Pour formater une chaîne JSON existante, parsez d’abord : JSON.stringify(JSON.parse(raw), null, 2).

Comment pretty-print JSON en ligne de commande ?

Utilisez jq . file.json (formate par défaut) ou python3 -m json.tool file.json si jq n’est pas installé. Ajoutez --sort-keys pour trier les clés.

Quelle est la différence entre formater et minifier JSON ?

Le formatage ajoute des blancs pour la lisibilité ; la minification les retire pour réduire la taille. Ce sont exactement deux opérations inverses qui préservent les données. Voir Comment minifier du JSON.

Formater du JSON change-t-il les données ?

Non. L’indentation et les sauts de ligne sont des blancs insignifiants en JSON —— tout parseur produit la même structure depuis une entrée compacte ou embellie.

Formater du JSON en ligne —— sans installation

Si vous devez formater une chaîne JSON maintenant sans écrire de code, JSON Fix formate votre JSON instantanément. Collez-le, cliquez sur Format et copiez le résultat. Il répare aussi les erreurs courantes (virgules finales, guillemets simples, clés sans guillemets) avant de formater, donc ça fonctionne même si votre JSON n’est pas encore tout à fait valide.