Wie überprüft man, ob JSON die richtigen Felder…

Es gibt mehrere Ansätze:

Überprüfung der Feldpräsenz: Durchlaufen Sie die erwarteten Felder und überprüfen Sie deren Anwesenheit im 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"Feld '{field}' fehlt"
        return True, "Alle erwarteten Felder sind vorhanden"
    except json.JSONDecodeError:
        return False, "Ungültiges JSON"
    except Exception as e:
        return False, f"Fehler: {e}"

# Beispiel
json_data = '{"name": "Alice", "age": 30}'
expected = ["name", "age", "city"]
result, message = check_json_fields(json_data, expected)
print(result, message) # False Feld 'city' fehlt

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 erwarteten Felder sind vorhanden

Verwendung von JSON Schema: JSON Schema ist ein Wörterbuch zur Validierung der JSON-Struktur. Es ist der zuverlässigste und flexibelste Ansatz für komplexe Strukturen.

from jsonschema import validate, SchemaError

# Schema zur Validierung von JSON
schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer", "minimum": 0},
        "city": {"type": "string"}
    },
    "required": ["name", "age"] # Obligatorische Felder
}

def validate_json_with_schema(json_data, schema):
    try:
        validate(instance=json_data, schema=schema)
        return True, "JSON entspricht dem Schema"
    except SchemaError as e:
        return False, f"Fehler im Schema: {e.message}"
    except Exception as e:
        return False, f"Validierungsfehler: {e.message}"

# Beispiel
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 entspricht dem Schema

invalid_data = {"name": "Bob"} # Fehlt 'age'
result_invalid, message_invalid = validate_json_with_schema(invalid_data, schema)
print(result_invalid, message_invalid) # False Validierungsfehler: 'age' ist eine erforderliche Eigenschaft

invalid_type_data = {"name": "Charlie", "age": "twenty"} # Falscher Typ für 'age'
result_type_invalid, message_type_invalid = validate_json_with_schema(invalid_type_data, schema)
print(result_type_invalid, message_type_invalid) # False Validierungsfehler: 'twenty' ist kein 'integer'

Verwendung von Bibliotheken zur Typ- und Strukturanalyse: Einige Sprachen haben Bibliotheken, die es erlauben, die Datenstruktur deklarativer zu definieren.
- Python: Pydantic, Marshmallow.
- JavaScript: Joi, Yup.
Eigene Validierungsfunktionen: Für spezielle Fälle oder komplexe Logik können eigene Validierungsfunktionen geschrieben werden.

Die Wahl der Methode hängt von der Komplexität der JSON-Struktur, den Anforderungen an die Strenge der Kontrolle und dem verwendeten Technologiestack ab. JSON Schema ist der empfohlene Ansatz, um Zuverlässigkeit und Unterstützung zu gewährleisten.

Wie überprüft man, ob JSON die richtigen Felder enthält?