Comment vérifier que le JSON contient les bons…

Il existe plusieurs approches :

Vérification de la présence des champs : Parcourir les champs attendus et vérifier leur présence dans le JSON.

import json

def check_json_fields(json_string, expected_fields):
    try:
        data = json.loads(json_string)
        for field in expected_fields:
            if field not in data:
                return False, f"Le champ '{field}' est manquant"
        return True, "Tous les champs attendus sont présents"
    except json.JSONDecodeError:
        return False, "JSON incorrect"
    except Exception as e:
        return False, f"Erreur : {e}"

# Exemple d'utilisation
json_data = '{"name": "Alice", "age": 30}'
expected = ["name", "age", "city"]
result, message = check_json_fields(json_data, expected)
print(result, message) # False Le champ 'city' est manquant

json_data_valid = '{"name": "Bob", "age": 25}'
expected_valid = ["name", "age"]
result_valid, message_valid = check_json_fields(json_data_valid, expected_valid)
print(result_valid, message_valid) # True Tous les champs attendus sont présents

Utilisation de JSON Schema : JSON Schema est un dictionnaire pour valider la structure du JSON. C'est l'approche la plus fiable et flexible pour les structures complexes.

from jsonschema import validate, SchemaError

# Schéma pour valider le JSON
schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer", "minimum": 0},
        "city": {"type": "string"}
    },
    "required": ["name", "age"] # Champs obligatoires
}

def validate_json_with_schema(json_data, schema):
    try:
        validate(instance=json_data, schema=schema)
        return True, "Le JSON correspond au schéma"
    except SchemaError as e:
        return False, f"Erreur dans le schéma : {e.message}"
    except Exception as e:
        return False, f"Erreur de validation : {e.message}"

# Exemple d'utilisation
valid_data = {"name": "Alice", "age": 30, "city": "New York"}
result_valid, message_valid = validate_json_with_schema(valid_data, schema)
print(result_valid, message_valid) # True Le JSON correspond au schéma

invalid_data = {"name": "Bob"} # 'age' manquant
result_invalid, message_invalid = validate_json_with_schema(invalid_data, schema)
print(result_invalid, message_invalid) # False Erreur de validation : 'age' est une propriété requise

invalid_type_data = {"name": "Charlie", "age": "twenty"} # Mauvais type pour 'age'
result_type_invalid, message_type_invalid = validate_json_with_schema(invalid_type_data, schema)
print(result_type_invalid, message_type_invalid) # False Erreur de validation : 'twenty' n'est pas de type 'integer'

Utilisation de bibliothèques pour vérifier les types et la structure : Certains langages disposent de bibliothèques permettant de définir la structure de données de manière plus déclarative.
- Python : Pydantic, Marshmallow.
- JavaScript : Joi, Yup.
Écriture de vérifications personnalisées : Pour des cas spécifiques ou une logique complexe, vous pouvez écrire vos propres fonctions de validation.

Le choix de la méthode dépend de la complexité de la structure JSON, des exigences en matière de rigueur du contrôle et de la pile technologique utilisée. JSON Schema est la méthode la plus recommandée pour assurer la fiabilité et le support.

Comment vérifier que le JSON contient les bons champs?