Formatage et validation JSON : Guide de référence rapide pour les développeurs

JSON (JavaScript Object Notation) est la lingua franca des API web. Simple par conception — mais une virgule manquante ou une accolade mal fermée peut silencieusement casser une application. Voici tout ce dont vous avez besoin pour travailler avec JSON en toute confiance.

La syntaxe JSON en 90 secondes

JSON possède exactement six types de valeurs :

{
  "string": "hello world",
  "number": 42,
  "boolean": true,
  "null_value": null,
  "array": [1, 2, 3],
  "object": { "nested": "value" }
}

Les règles qui piègent tout le monde :

• Les clés doivent être des chaînes entre guillemets doubles — {name: "Alice"} n'est pas du JSON valide
• Pas de virgule finale — [1, 2, 3,] est invalide
• Pas de commentaires — JSON ne dispose pas de syntaxe // ou /* */
• Les chaînes doivent utiliser des guillemets doubles — les guillemets simples ne sont pas autorisés
• Les nombres ne peuvent pas avoir de zéros en tête — 007 est invalide

Les erreurs JSON les plus courantes

1. Virgule finale

// Invalid
{ "a": 1, "b": 2, }

// Valid
{ "a": 1, "b": 2 }

2. Chaînes entre guillemets simples

// Invalid
{ 'name': 'Alice' }

// Valid
{ "name": "Alice" }

3. Clés sans guillemets

// Invalid
{ name: "Alice" }

// Valid
{ "name": "Alice" }

4. Valeurs undefined ou NaN — Ces valeurs JavaScript n'existent pas en JSON. Utilisez null à la place.

Formatage vs minification

Le JSON formaté (pretty-printed) utilise l'indentation et les sauts de ligne pour améliorer la lisibilité :

{
  "user": {
    "id": 1,
    "name": "Alice"
  }
}

Le JSON minifié supprime tous les espaces :

{"user":{"id":1,"name":"Alice"}}

Utilisez le JSON formaté dans les fichiers de configuration et le code source. Utilisez le JSON minifié dans les réponses API et le stockage pour réduire la taille des données. Notre JSON Formatter bascule entre les deux en un seul clic.

Validation par JSON Schema

JSON Schema vous permet de définir la structure attendue d'un document JSON et de valider des données par rapport à celle-ci. C'est indispensable pour les contrats d'API et la validation des fichiers de configuration.

Un schéma simple :

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["name", "age"],
  "properties": {
    "name": { "type": "string" },
    "age": { "type": "integer", "minimum": 0 }
  }
}

Ce schéma rejette tout objet dont name ou age est absent, ou dont age est négatif. Le JSON Schema Validator vous permet de coller un schéma et des données pour les valider en temps réel.

Générer des types TypeScript depuis du JSON

Si vous recevez une réponse JSON d'une API et avez besoin d'interfaces TypeScript, collez le JSON dans notre convertisseur JSON to TypeScript. Il déduit les types à partir de la structure des données :

Entrée :

{ "id": 1, "name": "Alice", "active": true, "tags": ["admin"] }

Sortie :

interface Root {
  id: number;
  name: string;
  active: boolean;
  tags: string[];
}

JSONPath : interroger des données imbriquées

JSONPath est au JSON ce que XPath est au XML — un langage de requête pour extraire des valeurs depuis des structures imbriquées. Syntaxe de base :

Expression	Signification
$.store.book	La clé book à l'intérieur de store
$.store.book[0]	Premier livre
$.store.book[*].title	Tous les titres de livres
$..price	Toutes les valeurs price dans l'ensemble du document

Le JSON Path Finder vous permet de cliquer sur n'importe quelle valeur dans un arbre JSON rendu et copie automatiquement le chemin.

Comparer deux objets JSON

Lors du débogage de modifications d'API ou de dérives de configuration, vous devez voir ce qui a changé entre deux objets JSON. Le JSON Diff Viewer met en évidence les champs ajoutés, supprimés et modifiés côte à côte.

Convertir du JSON en schéma Zod

Si vous utilisez Zod pour la validation à l'exécution en TypeScript, l'outil JSON to Zod convertit un exemple de JSON en schéma Zod prêt à l'emploi, avec une inférence de type intelligente pour les champs email, URL et datetime.

Résumé

JSON est simple mais implacable. Validez toujours avant de parser, utilisez des interfaces TypeScript pour détecter les incompatibilités de structure à la compilation, et gardez un formateur à portée de main pour déboguer les réponses API. Ces bonnes pratiques permettent d'éviter des catégories entières de bugs à l'exécution.