¿Cómo verificar que un JSON contiene los campos…

Existen varios enfoques:

Verificación de la presencia de campos: Iterar sobre los campos esperados y verificar su presencia en el 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"El campo '{field}' falta"
        return True, "Todos los campos esperados están presentes"
    except json.JSONDecodeError:
        return False, "JSON incorrecto"
    except Exception as e:
        return False, f"Error: {e}"

# Ejemplo de uso
json_data = '{"name": "Alice", "age": 30}'
expected = ["name", "age", "city"]
result, message = check_json_fields(json_data, expected)
print(result, message) # False El campo 'city' falta

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 Todos los campos esperados están presentes

Uso de JSON Schema: JSON Schema es un diccionario para validar la estructura del JSON. Es el método más confiable y flexible para estructuras complejas.

from jsonschema import validate, SchemaError

# Esquema para validar JSON
schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer", "minimum": 0},
        "city": {"type": "string"}
    },
    "required": ["name", "age"] # Campos obligatorios
}

def validate_json_with_schema(json_data, schema):
    try:
        validate(instance=json_data, schema=schema)
        return True, "El JSON cumple con el esquema"
    except SchemaError as e:
        return False, f"Error en el esquema: {e.message}"
    except Exception as e:
        return False, f"Error de validación: {e.message}"

# Ejemplo de uso
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 El JSON cumple con el esquema

invalid_data = {"name": "Bob"} # Falta 'age'
result_invalid, message_invalid = validate_json_with_schema(invalid_data, schema)
print(result_invalid, message_invalid) # False Error de validación: 'age' es una propiedad requerida

invalid_type_data = {"name": "Charlie", "age": "twenty"} # Tipo incorrecto para 'age'
result_type_invalid, message_type_invalid = validate_json_with_schema(invalid_type_data, schema)
print(result_type_invalid, message_type_invalid) # False Error de validación: 'twenty' no es de tipo 'integer'

Uso de bibliotecas para verificar tipos y estructura: Algunos lenguajes tienen bibliotecas que permiten definir la estructura de datos de manera más declarativa.
- Python: Pydantic, Marshmallow.
- JavaScript: Joi, Yup.
Escribir verificaciones personalizadas: Para casos específicos o lógica compleja, se pueden escribir funciones de validación propias.

La elección del método depende de la complejidad de la estructura JSON, los requisitos de rigidez en el control y la pila tecnológica utilizada. JSON Schema es el método más recomendado para garantizar la fiabilidad y el soporte.

¿Cómo verificar que un JSON contiene los campos correctos?