Hoe controleer je of JSON de juiste velden bevat…

Er zijn verschillende benaderingen:

Controleren op aanwezigheid van velden: Itereer door de verwachte velden en controleer of ze aanwezig zijn in de 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"Veld '{field}' ontbreekt"
        return True, "Alle verwachte velden zijn aanwezig"
    except json.JSONDecodeError:
        return False, "Ongeldige JSON"
    except Exception as e:
        return False, f"Fout: {e}"

# Voorbeeld van gebruik
json_data = '{"name": "Alice", "age": 30}'
expected = ["name", "age", "city"]
result, message = check_json_fields(json_data, expected)
print(result, message) # False Veld 'city' ontbreekt

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 Alle verwachte velden zijn aanwezig

Gebruik van JSON Schema: JSON Schema is een woordenboek voor het valideren van de structuur van JSON. Dit is de meest betrouwbare en flexibele aanpak voor complexe structuren.

from jsonschema import validate, SchemaError

# Schema voor validatie van JSON
schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer", "minimum": 0},
        "city": {"type": "string"}
    },
    "required": ["name", "age"] # Verplichte velden
}

def validate_json_with_schema(json_data, schema):
    try:
        validate(instance=json_data, schema=schema)
        return True, "JSON komt overeen met het schema"
    except SchemaError as e:
        return False, f"Fout in schema: {e.message}"
    except Exception as e:
        return False, f"Validatiefout: {e.message}"

# Voorbeeld
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 JSON komt overeen met het schema

invalid_data = {"name": "Bob"} # 'age' ontbreekt
result_invalid, message_invalid = validate_json_with_schema(invalid_data, schema)
print(result_invalid, message_invalid) # False Validatiefout: 'age' is een vereist veld

invalid_type_data = {"name": "Charlie", "age": "twenty"} # Verkeerd type
result_type_invalid, message_type_invalid = validate_json_with_schema(invalid_type_data, schema)
print(result_type_invalid, message_type_invalid) # False Validatiefout: 'twenty' is niet van type 'integer'

Gebruik van bibliotheken voor het controleren van types en structuur: Sommige talen beschikken over bibliotheken die het mogelijk maken om de datastructuur meer declaratief te definiëren.
- Python: Pydantic, Marshmallow.
- JavaScript: Joi, Yup.
Schrijven van aangepaste validatiefuncties: Voor specifieke gevallen of complexe logica kunnen eigen validatiefuncties worden geschreven.

De keuze van de methode hangt af van de complexiteit van de JSON-structuur, de eisen aan de strengheid van de controle en de gebruikte technologische stack. JSON Schema wordt aanbevolen als de meest betrouwbare aanpak om betrouwbaarheid en ondersteuning te garanderen.

Hoe controleer je of JSON de juiste velden bevat?