Comment valider du JSON : guide complet avec exemples

JSON (JavaScript Object Notation) est la pierre angulaire des API Web modernes, des fichiers de configuration et de l'échange de données. Mais un JSON invalide peut faire planter des applications, faire échouer des intégrations d'API et causer des heures de débogage frustrant. Ce guide vous explique tout ce que vous devez savoir pour valider du JSON, des vérifications de syntaxe de base à la validation avancée par Schema avec des exemples concrets.

Pourquoi la validation JSON est importante

Le JSON invalide est l'une des sources d'erreurs les plus courantes dans les applications Web. Une virgule mal placée, une clé non entre guillemets ou une virgule finale peuvent faire en sorte que JSON.parse() lève une SyntaxError, faisant ainsi s'effondrer tout le pipeline de données. La validation permet de détecter ces erreurs tôt, avant qu'elles ne se propagent dans le système et ne causent des défaillances en aval.

Au-delà de l'exactitude syntaxique, la validation garantit également que les données JSON respectent la structure attendue. Une API peut renvoyer du JSON valide, mais avec des champs manquants, des types de données incorrects ou des valeurs hors de la plage acceptable. La validation par Schema résout ces problèmes structurels.

Règles de syntaxe JSON

Avant d'approfondir les outils de validation, il est essentiel de comprendre les règles qui rendent le JSON valide. JSON a une syntaxe stricte définie par la RFC 8259, où même un seul caractère non conforme invalide le document entier.

Les chaînes doivent utiliser des guillemets doubles

Toutes les valeurs de chaîne et les clés d'objet doivent être entourées de guillemets doubles. Les guillemets simples ne sont pas des délimiteurs de chaîne JSON valides, c'est une erreur courante pour les développeurs venant de JavaScript.

// Invalid - single quotes
{'name': 'Alice', 'age': 30}

// Valid - double quotes
{"name": "Alice", "age": 30}

Les clés d'objet doivent être entre guillemets

Contrairement aux littéraux d'objet JavaScript, JSON exige que toutes les clés d'objet soient entourées de guillemets doubles. Les clés non entre guillemets sont une erreur de syntaxe.

// Invalid - unquoted keys
{name: "Alice", age: 30}

// Valid - quoted keys
{"name": "Alice", "age": 30}

Pas de virgule finale autorisée

JSON n'autorise pas les virgules après le dernier élément d'un objet ou d'un tableau. C'est une autre erreur courante, en particulier lors de l'édition manuelle de JSON.

// Invalid - trailing comma
{
  "name": "Alice",
  "age": 30,
}

// Valid - no trailing comma
{
  "name": "Alice",
  "age": 30
}

Pas de commentaires pris en charge

JSON ne prend pas en charge les commentaires. Les commentaires sur une ligne // et les commentaires multilignes /* */ ne sont pas valides en JSON. Si vous avez besoin de documentation, utilisez un fichier séparé ou un format comme JSONC.

Erreurs courantes de validation JSON

Connaître les erreurs les plus courantes vous aide à les repérer et à les corriger rapidement. Voici les erreurs que vous rencontrerez le plus souvent :

• Jeton inattendu : généralement causé par des guillemets simples, des clés non entre guillemets ou une virgule finale. Le message d'erreur contient la position où l'analyse a échoué.
• Fin inattendue de l'entrée JSON : la chaîne JSON est incomplète ou vide. Cela se produit souvent lorsqu'une requête réseau renvoie une réponse vide.
• Caractère non blanc inattendu : contenu supplémentaire après la valeur JSON principale, par exemple un deuxième objet non enveloppé dans un tableau.
• Nombre invalide : les nombres avec des zéros en tête (sauf 0 lui-même), la notation hexadécimale ou les valeurs NaN / Infinity ne sont pas du JSON valide.

Valider du JSON en JavaScript

La méthode la plus simple pour valider du JSON en JavaScript est d'encapsuler JSON.parse() dans un bloc try-catch. Si le JSON est invalide, la méthode lève une SyntaxError.

function validateJSON(jsonString) {
  try {
    JSON.parse(jsonString);
    return { valid: true };
  } catch (error) {
    return {
      valid: false,
      error: error.message
    };
  }
}

const result = validateJSON('{"name": "Alice"}');
console.log(result);
// { valid: true }

const badResult = validateJSON("{'name': 'Alice'}");
console.log(badResult);
// { valid: false, error: "Unexpected token '..." }

Valider du JSON en Python

Python fournit le module json avec json.loads() pour analyser les chaînes JSON. Comme en JavaScript, un JSON invalide lève une json.JSONDecodeError avec des informations détaillées sur la position.

import json

def validate_json(json_string):
    try:
        json.loads(json_string)
        return {"valid": True}
    except json.JSONDecodeError as e:
        return {
            "valid": False,
            "error": str(e),
            "line": e.lineno,
            "column": e.colno
        }

result = validate_json('{"name": "Alice"}')
print(result)
# {'valid': True}

Validation par JSON Schema

La validation syntaxique peut seulement vous dire si le JSON est bien formaté. JSON Schema vous permet de définir la structure attendue et de valider les données selon celle-ci. Le Schema spécifie les champs obligatoires, les types de données, les plages de valeurs, les motifs de chaîne et la structure des objets imbriqués.

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "required": ["name", "email"],
  "properties": {
    "name": { "type": "string", "minLength": 1 },
    "email": { "type": "string", "format": "email" },
    "age": { "type": "integer", "minimum": 0 }
  }
}

Les validateurs JSON Schema populaires incluent Ajv pour JavaScript, jsonschema pour Python et json-schema-validator pour Java. Ces bibliothèques valident vos données JSON selon votre Schema et génèrent des messages d'erreur détaillés pour chaque violation.

Outils de validation JSON en ligne

Lorsque vous devez vérifier rapidement un document JSON sans écrire de code, les validateurs en ligne sont l'option la plus rapide. Ils fournissent un retour instantané avec mise en évidence des erreurs et numéros de ligne.

Meilleures pratiques de validation JSON

• Validez tôt : vérifiez le JSON aux frontières du système (comme les points d'extrémité d'API et les fonctions d'importation de fichiers), avant que les données n'entrent dans la logique métier.
• Utilisez la validation par Schema : au-delà de la syntaxe, utilisez JSON Schema pour valider la structure des données afin de détecter les champs manquants, les types incorrects et les valeurs hors plage.
• Fournissez des messages d'erreur clairs : lorsque la validation échoue, incluez le chemin du champ, le type attendu et la valeur réelle pour aider les utilisateurs à corriger rapidement le problème.
• Validez côté client et côté serveur : la validation côté client fournit un retour immédiat, tandis que la validation côté serveur garantit la sécurité et l'intégrité des données.
• Automatisez la validation dans CI/CD : utilisez des outils comme ajv-cli ou jsonschema pour valider les fichiers JSON fixes et les fichiers de configuration dans le pipeline de build.
• Journalisez les erreurs de validation : enregistrez les échecs de validation avec le contexte pour identifier les modèles et corriger les causes profondes chez les producteurs de données.