Outil de Formatage JSON
Qu'est-ce qu'un Formateur JSON ?
Le formateur JSON rend lisible un JSON compact ou désordonné en ajoutant indentation, retours à la ligne et structure visible. JSON est utilisé dans les réponses d’API, configurations, logs, feature flags, données de test et intégrations no-code, où une virgule manquante, un guillemet incorrect ou une valeur imbriquée inattendue peut provoquer une erreur de parsing. L’outil aide à inspecter rapidement objets, tableaux, clés, valeurs et zones d’erreur probables, puis à recompacter si une charge plus petite est nécessaire. Le formatage ne change pas le sens des données et ne valide pas automatiquement un schéma métier. Types, champs obligatoires, null et contrats de version doivent être contrôlés séparément.
Comment utiliser
Comment utiliser
- Collez ou saisissez des données JSON dans la zone de saisie de gauche
- Sélectionnez la taille d'indentation (2 espaces, 4 espaces ou tabulation)
- Cliquez sur Format pour formater ou Minify pour supprimer les espaces
- Le résultat apparaît automatiquement à droite avec coloration syntaxique
- Cliquez sur Copy ou Download pour enregistrer le résultat
Notes de validation JSON
- Le formatage prouve que le texte est un JSON valide, mais ne garantit pas que les données correspondent à votre schéma métier.
- Lorsqu'une erreur apparaît, vérifiez la ligne et la colonne indiquées à la recherche de guillemets simples, virgules finales, commentaires ou caractères de contrôle non échappés.
Cas d’utilisation
Principe technique
JSON (JavaScript Object Notation) est défini par la RFC 8259 / ECMA-404. La grammaire est un sous-ensemble strict des littéraux objets JavaScript : les chaînes doivent être entourées de guillemets doubles, les clés doivent être guillemetées, les virgules finales sont interdites et les commentaires sont proscrits. Un formateur parse le document avec `JSON.parse()` en un graphe d'objets du langage hôte, puis le resérialise via `JSON.stringify(value, replacer, indent)` où indent est un nombre (1 à 10 espaces) ou une chaîne (`'\t'`). Le parsing est en O(n) et est généralement plus rapide que la phase de stringify car la construction de la sortie alloue de nouvelles chaînes. La gestion des nombres suit la norme IEEE 754 double précision : les entiers supérieurs à `Number.MAX_SAFE_INTEGER` (2^53 - 1 = 9007199254740991) perdent en précision, donc `9007199254740993` revient à `9007199254740992` après un cycle. Les décimales à répétition comme `0.1 + 0.2` se résolvent en `0.30000000000000004` après parsing. Les chaînes Unicode autorisent les échappements `\uXXXX` y compris les paires de surrogates (`\uD83D\uDE00` → 😀) ; le parseur rejette les surrogates isolés non appairés. L'espace blanc n'est significatif qu'à l'intérieur des chaînes — toute combinaison d'espace, tabulation, LF, CR entre les tokens se parse de manière identique. Les relaxations non standard courantes sont JSON5 (commentaires, virgules finales, clés non guillemetées) et JSONC (configuration VS Code). Le JSON standard ne les autorise pas et `JSON.parse` lance une `SyntaxError` en cas de rencontre. Les alternatives en flux comme NDJSON (un objet par ligne) et JSON Lines évitent de charger des documents entiers en mémoire. Pour des entrées profondément imbriquées, la limite de pile de V8 (~10 000 cadres) plafonne les parseurs récursifs ; les parseurs de production utilisent des machines à états itératives pour lever cette contrainte.
- Grammaire RFC 8259 / ECMA-404 — six types de valeurs (objet, tableau, chaîne, nombre, vrai/faux, null) ; chaînes en guillemets doubles ; clés obligatoirement guillemetées ; pas de virgules finales ; pas de commentaires.
- `JSON.parse(text)` s'exécute en O(n) et lance `SyntaxError` avec le décalage en caractères sur entrée invalide ; `JSON.stringify(value, replacer, indent)` produit une sortie formatée avec une indentation de 2 à 10 espaces ou `'\t'`.
- Précision des nombres IEEE 754 : `Number.MAX_SAFE_INTEGER = 2^53 - 1` ; les entiers au-delà sont arrondis au double représentable le plus proche, donc les IDs de chat et les IDs Twitter Snowflake doivent être transportés sous forme de chaînes.
- Les échappements Unicode `\uXXXX` couvrent tout le BMP ; les caractères hors BMP nécessitent l'encodage par paire de surrogates `\uD83D\uDE00` ; le parseur rejette les surrogates isolés non appairés selon la RFC 8259 §8.2.
- Échecs de parsing courants : chaînes en guillemets simples (`'foo'`), virgule finale après le dernier élément de tableau/objet, caractères de contrôle non échappés dans les chaînes, antislash non échappé, `}`/`]` fermant manquant, BOM (`\uFEFF`) en début de fichier.
- Les références circulaires lancent `TypeError: cyclic object value` dans `JSON.stringify` ; utilisez un callback `replacer` avec un WeakSet pour casser les cycles, ou des bibliothèques comme `flatted` / `json-stringify-safe`.
- Variantes non standard : JSON5 (`.json5`, autorise commentaires et virgules finales), JSONC (configuration VS Code), NDJSON / JSON Lines (un objet par ligne, adapté au flux) — tous rejetés par le `JSON.parse` strict.
Exemples
Exemple d'objet
Entrée:
{
"name": "ToolAct",
"type": "web tool",
"active": true
}
Sortie: mise en forme avec indentation de 2 espaces et ordre des clés stableExemple de tableau
Entrée: [1,2,3,"a","b","c"]
Sortie: formaté avec une indentation de 2 espaces ; les nombres restent numériques, les chaînes conservent leurs guillemetsStructure imbriquée
Entrée:
{"user":{"name":"Alex","skills":["JavaScript","Python"]}}
Sortie:
{
"user": {
"name": "Alex",
"skills": [
"JavaScript",
"Python"
]
}
}
Note: les objets et tableaux imbriqués sont indentés récursivement ; la largeur d'indentation se choisit dans la barre d'outilsFAQ
Que fait le formateur ?
Il reformate le JSON : impression lisible avec l'indentation choisie (2 ou 4 espaces) ou minification sur une seule ligne. La validation se fait pendant l'analyse, donc les erreurs de syntaxe sont signalées avec leur ligne et colonne.
Pourquoi mon JSON est-il rejeté comme invalide ?
Causes courantes : virgules finales (légales en JS, illégales en JSON), chaînes entre guillemets simples (doivent être doubles), clés sans guillemets, commentaires (// ou /* */), ou accolades manquantes. La page indique l'emplacement de l'échec d'analyse. JSON5 et JSONC (JSON avec commentaires) sont des sur-ensembles de JSON — utilisez un autre analyseur pour ces formats.
L'ordre des clés est-il préservé ?
La spécification JSON dit que l'ordre des clés n'est pas significatif, mais la plupart des analyseurs le préservent à l'aller-retour. Cet outil conserve l'ordre d'insertion, ce qui est généralement préférable pour des diffs lisibles.
Peut-il gérer de très gros fichiers JSON ?
Les navigateurs modernes traitent des fichiers JSON de 10 à 50 Mo, mais peuvent ralentir l'éditeur. Pour des fichiers de plusieurs centaines de Mo, utilisez un analyseur en flux (jq en ligne de commande, outils ndjson) ; les analyseurs de navigateur chargent l'arbre entier en mémoire.
Mon JSON est-il téléversé ?
Non. L'analyse et le formatage s'exécutent dans votre navigateur via JSON.parse et JSON.stringify. Le JSON collé n'est pas transmis.
Pourquoi les grands nombres perdent-ils en précision ?
JSON.parse de JavaScript utilise Number, qui est un IEEE 754 double précision. Les entiers au-delà de 2^53 perdent en précision (par exemple 9007199254740993 est arrondi silencieusement). Pour conserver des BigInt ou des chaînes, utilisez un analyseur personnalisé ou pré-marquez les grands nombres comme chaînes côté producteur.
Et JSONC (JSON avec commentaires) ?
Le JSON strict interdit les commentaires. Certains IDE (fichiers de configuration de VS Code) utilisent JSONC, qui ajoute les commentaires // et /* */. Le formateur prend généralement en charge un mode « JSONC » qui préserve les commentaires ; en mode strict, les commentaires sont une erreur de syntaxe.