Validateur JSON

Qu'est-ce que la validation JSON ?

JSON (JavaScript Object Notation) est un format d'échange de données léger et largement adopté, conçu pour être à la fois lisible par l'humain et facile à analyser et générer par les machines. Son objectif principal est de représenter des données structurées — objets, tableaux, chaînes de caractères, nombres, booléens et valeurs nulles — de manière indépendante du langage de programmation.

La validation JSON est le processus de vérification programmée qu'un document JSON est à la fois syntaxiquement et structurellement correct. Cela implique de contrôler deux aspects principaux :

• Validation syntaxique: S'assurer que le texte brut respecte la grammaire formelle définie par la spécification JSON ECMA-404. Les analyseurs syntaxiques dans la plupart des langages de programmation modernes (par exemple, JSON.parse() en JavaScript, json.loads() en Python, JSONDecoder en Java) nécessitent une syntaxe valide et génèrent des erreurs si les données en entrée sont mal formées.
• Validation Structurelle (Schéma): Au-delà de la syntaxe, la validation de schéma vérifie que les données JSON correspondent à une structure attendue, incluant les types de données, les propriétés obligatoires, les contraintes de valeur et les objets/tableaux imbriqués. La validation de schéma est généralement réalisée à l'aide de JSON Schema, qui définit les règles pour ce qui est considéré comme des données valides.

Pourquoi valider le JSON ?

La validation JSON est essentielle partout où les données sont sérialisées pour la transmission, le stockage ou la communication entre services. Les raisons principales incluent :

• Prévention des erreurs : détectez et signalez rapidement les erreurs de syntaxe (par exemple, virgules manquantes, crochets non appariés, caractères illégaux) avant de tenter de traiter les données.
• Intégrité et Sécurité des Données : Rejetez les charges JSON malformées ou malveillantes, contribuant ainsi à prévenir les plantages du serveur, les attaques par injection ou la corruption des données.
• Sécurité des types : Faites respecter un typage strict—en garantissant, par exemple, qu’un champ censé être un booléen ne soit pas envoyé sous forme de chaîne, ou que les UUID, adresses e-mail ou nombres respectent le format approprié.
• Compatibilité inter-langages : garantissez que le JSON généré dans un environnement (par exemple, Node.js) soit exploitable en toute sécurité dans un autre (par exemple, Python, Go, Java), en évitant les erreurs de sérialisation/désérialisation.
• Maintenabilité et Robustesse : Les structures de données validées améliorent la traçabilité et réduisent le risque d'erreurs difficiles à déboguer dans les fichiers de configuration, les journaux ou les requêtes/réponses API.
• Confidentialité et sécurité : La validation peut être effectuée entièrement côté client (dans le navigateur), empêchant ainsi que des données brutes ou sensibles quittent l'appareil de l'utilisateur pour la validation.

Erreurs courantes de validation JSON (avec exemples détaillés)

Clés non citées

Toutes les clés dans les objets JSON doivent être des chaînes de caractères entre guillemets doubles.

{ name: "Alice" }

{ "name": "Alice" }

De nombreux formats similaires à JSON (par exemple, les littéraux d'objets JavaScript) autorisent des clés non entre guillemets, mais le JSON standard ne le permet pas.

Guillemets Simples

Les chaînes JSON doivent utiliser uniquement des guillemets doubles ; les guillemets simples ne sont pas autorisés.

{ 'name': 'Bob' }

{ "name": "Bob" }

L'utilisation des guillemets simples entraînera des erreurs de parseur dans toutes les bibliothèques JSON conformes.

Virgules finales

Pas de virgule finale après le dernier élément d'un objet ou d'un tableau.

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

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

Les virgules finales peuvent fonctionner en JavaScript, mais pas dans les analyseurs JSON stricts.

Échappement Incorrect des Caractères

Les guillemets et caractères spéciaux à l'intérieur des chaînes doivent être échappés à l'aide d'un antislash.

{ "quote": "Tom a dit \"bonjour\"" }

{ "quote": "Tom a dit \"bonjour\"" }

Parmi les autres séquences d'échappement figurent \\ pour la barre oblique inverse, \n pour les sauts de ligne, et \t pour les tabulations.

Types de données incorrects

Les chaînes de caractères ne doivent pas être utilisées pour les nombres, les booléens ou la valeur nulle.

{ "enabled": "vrai", "count": "10" }

{ "activé": true, "compte": 10 }

JSON fait la distinction entre booléens, nombres et chaînes de caractères — assurez-vous d'utiliser le bon type.

Clés non primitives

Les clés d’un objet JSON doivent toujours être des chaînes de caractères ; vous ne pouvez pas utiliser des nombres, des booléens ou d’autres types comme clés.

{ 123: "abc" }

{ "123": "abc" }

Clés Dupliquées

Bien que permis par la spécification JSON, les clés dupliquées sont une source fréquente de bugs.

{ "name": "Alice", "name": "Bob" }

La plupart des analyseurs conservent uniquement la dernière valeur (« Bob »), en ignorant silencieusement les précédentes.

Utilisation des Commentaires

Le format JSON standard n'autorise pas les commentaires, même si certains éditeurs les prennent en charge.

{
  // Informations utilisateur
  "name": "Alice"
}

{
  "name": "Alice"
}

Validation de Schéma : Imposer la Structure et les Types de Données

Le schéma JSON est une norme puissante pour définir et valider la structure attendue des documents JSON. Il vous permet de spécifier :

• Champs obligatoires (`required`)
• Types de données (`type` : chaîne, nombre, booléen, objet, tableau, null)
• Formats de chaîne (`format` : email, uuid, date-heure, etc.)
• Recherche de motifs pour chaînes de caractères (`pattern`)
• Plages de nombres (`minimum`, `maximum`)
• Longueur du tableau et validation des éléments (`minItems`, `maxItems`, `items`)
• Validation imbriquée pour objets et tableaux
• Contraintes d'énumération (`enum`)

Exemple : Schéma Utilisateur (Brouillon-07)

{
  "type": "object",
  "properties": {
    "id":    { "type": "string", "format": "uuid" },
    "name":  { "type": "string", "minLength": 1 },
    "email": { "type": "string", "format": "email" },
    "is_active": { "type": "boolean" }
  },
  "required": ["id", "name", "email"],
  "additionalProperties": false
}

Ce que cela implique :

• L'identifiant doit être une chaîne UUID valide.
• le nom doit être une chaîne de caractères non vide.
• l'email doit correspondre au format standard d'adresse email.
• is_active (optionnel) doit être un booléen.
• Aucune propriété autre que celles définies ci-dessus n'est autorisée.

Exemple Pratique : Validation des Réponses de l'API Stripe

Supposons que vous receviez des réponses JSON de l'API Stripe (par exemple, PaymentIntent). La validation de schéma garantit que vous ne traitez jamais de données incomplètes ou mal typées.

{
  "type": "object",
  "properties": {
    "id":      { "type": "string", "pattern": "^pi_" },
    "object":  { "type": "string", "const": "payment_intent" },
    "amount":  { "type": "integer", "minimum": 1 },
    "currency":{ "type": "string", "minLength": 3, "maxLength": 3 },
    "status":  { "type": "string", "enum": [
      "requires_payment_method",        
      "requires_confirmation",         
      "processing",                    
      "succeeded",                    
      "canceled"                     
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• l'identifiant doit commencer par "pi_"
• l'objet doit toujours être "payment_intent"
• le montant doit être un entier supérieur ou égal à 1
• la devise doit être une chaîne de trois lettres (par exemple, "usd", "eur")
• le statut doit être l'une des valeurs spécifiées

Avantages

• Détection précoce des erreurs : Identifiez les modifications majeures d’API ou les données incomplètes avant qu’elles n’impactent votre logique métier.
• Tests automatisés : Utilisez des schémas dans les pipelines CI/CD pour valider les réponses réelles et simulées.
• Cohérence inter-équipes : Standardisez les contrats de données entre le frontend, le backend et les API tierces.

Une validation JSON appropriée—couvrant à la fois la syntaxe et le schéma—prévient les bugs subtils, applique les meilleures pratiques et protège vos applications contre les entrées malformées ou malveillantes. Qu'elle soit utilisée dans les fichiers de configuration, les charges utiles d'API ou la messagerie interservices, une validation rigoureuse est essentielle pour les systèmes logiciels modernes.

Confidentialité et Sécurité

Toutes les validations et vérifications de schéma s'exécutent localement dans votre navigateur. Aucune donnée n'est téléchargée ni enregistrée. Votre JSON reste totalement privé.

Exemples de code pour la validation JSON

Découvrez comment valider du JSON dans différents langages de programmation en utilisant des bibliothèques intégrées ou des frameworks populaires. Ces exemples illustrent à la fois la validation de la syntaxe et la validation selon un schéma.

const jsonString = '{"name":"Alice","age":30}';
try {
  const obj = JSON.parse(jsonString);
  console.log("Valid JSON:", obj);
} catch (e) {
  console.error("Invalid JSON!", e.message);
}

const Ajv = require("ajv");
const ajv = new Ajv();
const schema = { type: "object", properties: { age: { type: "integer" } }, required: ["age"] };
const data = { age: 30 };
const validate = ajv.compile(schema);
console.log(validate(data) ? "Valid!" : ajv.errorsText(validate.errors));

import json
try:
    obj = json.loads('{"name":"Alice","age":30}')
    print("Valid JSON:", obj)
except json.JSONDecodeError as e:
    print("Invalid JSON:", e)

import json, jsonschema
schema = {
    "type": "object",
    "properties": { "age": { "type": "integer" } },
    "required": ["age"]
}
data = {"age": 30}
try:
    jsonschema.validate(data, schema)
    print("Valid!")
except jsonschema.ValidationError as e:
    print("Schema validation error:", e)

package main
import (
  "encoding/json"
  "fmt"
)
func main() {
  data := []byte(`{"name":"Alice","age":30}`)
  var obj map[string]interface{}
  if err := json.Unmarshal(data, &obj); err != nil {
    fmt.Println("Invalid JSON:", err)
  } else {
    fmt.Println("Valid JSON:", obj)
  }
}

import com.fasterxml.jackson.databind.ObjectMapper;
public class Main {
  public static void main(String[] args) {
    String json = "{"name":"Alice","age":30}";
    try {
      Object obj = new ObjectMapper().readTree(json);
      System.out.println("Valid JSON: " + obj);
    } catch (Exception e) {
      System.out.println("Invalid JSON: " + e.getMessage());
    }
  }
}

using System;
using System.Text.Json;
class Program {
  static void Main() {
    string json = "{"name":"Alice","age":30}";
    try {
      var doc = JsonDocument.Parse(json);
      Console.WriteLine("Valid JSON!");
    } catch (JsonException e) {
      Console.WriteLine("Invalid JSON: " + e.Message);
    }
  }
}

<?php
$json = '{"name":"Alice","age":30}';
$obj = json_decode($json);
if (json_last_error() === JSON_ERROR_NONE) {
  echo "Valid JSON";
} else {
  echo "Invalid JSON: " . json_last_error_msg();
}

require 'json'
begin
  obj = JSON.parse('{"name":"Alice","age":30}')
  puts "Valid JSON!"
rescue JSON::ParserError => e
  puts "Invalid JSON: #{e.message}"
end

echo '{"name":"Alice","age":30}' | jq empty && echo "Valid" || echo "Invalid"

fn main() {
  let data = r#"{"name":"Alice","age":30}"#;
  match serde_json::from_str::<serde_json::Value>(data) {
    Ok(_) => println!("Valid JSON!"),
    Err(e) => println!("Invalid JSON: {}", e),
  }
}

import org.json.JSONObject
fun main() {
  try {
    val obj = JSONObject("{\"name\":\"Alice\",\"age\":30}")
    println("Valid JSON: $obj")
  } catch (e: Exception) {
    println("Invalid JSON: ${e.message}")
  }
}

import Foundation
let json = "{\"name\":\"Alice\",\"age\":30}"
if let data = json.data(using: .utf8) {
  do {
    let _ = try JSONSerialization.jsonObject(with: data)
    print("Valid JSON!")
  } catch {
    print("Invalid JSON: \(error)")
  }
}

const jsonString = '{"name":"Alice","age":30}';
try {
  const obj = JSON.parse(jsonString);
  console.log("Valid JSON:", obj);
} catch (e) {
  console.error("Invalid JSON!", e.message);
}

SELECT '{"name":"Alice","age":30}'::jsonb; -- Will error if not valid JSON

SELECT JSON_VALID('{"name":"Alice","age":30}');

$json = '{"name":"Alice","age":30}'
try {
  $obj = $json | ConvertFrom-Json
  Write-Output "Valid JSON!"
} catch {
  Write-Output "Invalid JSON: $($_.Exception.Message)"
}

use JSON;
my $str = '{"name":"Alice","age":30}';
eval { decode_json($str) };
print $@ ? "Invalid JSON: $@" : "Valid JSON!";

import 'dart:convert';
void main() {
  const jsonString = '{"name":"Alice","age":30}';
  try {
    final obj = jsonDecode(jsonString);
    print('Valid JSON: $obj');
  } catch (e) {
    print('Invalid JSON: $e');
  }
}

json = ~s({"name":"Alice","age":30})
case Jason.decode(json) do
  {:ok, _} -> IO.puts("Valid JSON!")
  {:error, err} -> IO.puts("Invalid JSON: #{err}")
end

import play.api.libs.json._
object Main extends App {
  val str = """{"name":"Alice","age":30}"""
  try {
    val json = Json.parse(str)
    println("Valid JSON!")
  } catch {
    case e: Exception => println("Invalid JSON: " + e.getMessage)
  }
}

À propos de cet outil