Validador JSON

¿Qué es la validación JSON?

JSON (Notación de Objetos de JavaScript) es un formato de intercambio de datos ligero y ampliamente adoptado, diseñado para ser legible tanto para humanos como fácil de analizar y generar para máquinas. Su propósito principal es representar datos estructurados — objetos, matrices, cadenas, números, booleanos y valores nulos — de una manera independiente del lenguaje.

La validación de JSON es el proceso de verificar de manera programática que un documento JSON sea correcto tanto sintáctica como estructuralmente. Esto implica revisar dos aspectos principales:

• Validación Sintáctica: Asegurando que el texto sin formato cumpla con la gramática formal definida por la especificación JSON ECMA-404. Los analizadores sintácticos en la mayoría de los lenguajes de programación modernos (por ejemplo, JSON.parse() en JavaScript, json.loads() en Python, JSONDecoder en Java) esperan una sintaxis válida y generarán errores si la entrada está malformada.
• Validación Estructural (Esquema): Más allá de la sintaxis, la validación de esquemas verifica que los datos JSON coincidan con una estructura esperada, incluyendo tipos de datos, propiedades obligatorias, restricciones de valores y objetos/arrays anidados. La validación de esquemas se realiza normalmente mediante JSON Schema, que define reglas para determinar qué datos se consideran válidos.

¿Por qué validar JSON?

La validación de JSON es fundamental siempre que los datos se serializan para transmisión, almacenamiento o comunicación entre servicios. Las razones clave incluyen:

• Prevención de Errores: Detecta y reporta errores de sintaxis (por ejemplo, comas faltantes, corchetes sin cerrar, caracteres ilegales) de manera temprana, antes de intentar procesar los datos.
• Integridad y Seguridad de Datos: Rechaza cargas JSON malformadas o maliciosas, ayudando a prevenir fallos en el backend, ataques de inyección o corrupción de datos.
• Seguridad de Tipos: Aplica un tipado estricto, asegurando, por ejemplo, que un campo esperado como booleano no se envíe como cadena de texto, o que los UUID, correos electrónicos y números cumplan con el formato adecuado.
• Compatibilidad Multilingüe: Garantiza que el JSON generado en un entorno (por ejemplo, Node.js) sea seguro y compatible para su uso en otro (por ejemplo, Python, Go, Java), evitando errores de serialización y deserialización.
• Mantenibilidad y Robustez: Las estructuras de datos validadas mejoran la trazabilidad y reducen el riesgo de errores difíciles de depurar en archivos de configuración, registros o solicitudes/respuestas de API.
• Privacidad y Seguridad: La validación puede realizarse completamente del lado del cliente (en el navegador), evitando que datos sin procesar o sensibles salgan del dispositivo del usuario para su validación.

Errores Comunes de Validación JSON (con Ejemplos Detallados)

Claves sin comillas

Todas las claves en objetos JSON deben ser cadenas entre comillas dobles.

{ nombre: "Alicia" }

{ "name": "Alicia" }

Muchos formatos similares a JSON (por ejemplo, literales de objetos en JavaScript) permiten claves sin comillas, pero el JSON estándar no lo permite.

Comillas simples

Las cadenas JSON deben usar solo comillas dobles; no se permiten comillas simples.

{ 'nombre': 'Bob' }

{ "name": "Bob" }

Usar comillas simples provocará errores de análisis en todas las bibliotecas JSON compatibles.

Comas al Final

No debe haber coma al final después del último elemento en un objeto o arreglo.

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

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

Las comas al final pueden funcionar en JavaScript, pero no en los analizadores estrictos de JSON.

Escape Incorrecto de Caracteres

Las comillas y caracteres especiales dentro de cadenas deben ser escapados usando una barra invertida.

{ "quote": "Tom dijo \"hola\"" }

{ "quote": "Tom dijo \"hola\"" }

Otras secuencias de escape incluyen \\ para barra invertida, \n para saltos de línea y \t para tabulaciones.

Tipos de Datos Incorrectos

No se deben usar cadenas para números, valores booleanos ni nulos.

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

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

JSON diferencia entre booleanos, números y cadenas—asegúrate de usar el tipo correcto.

Claves No Primitivas

Las claves de los objetos JSON deben ser siempre cadenas; no se pueden utilizar números, booleanos u otros tipos como claves.

{ 123: "abc" }

{ "123": "abc" }

Claves duplicadas

Aunque está permitido por la especificación JSON, las claves duplicadas son una fuente común de errores.

{ "name": "Alicia", "name": "Roberto" }

La mayoría de los analizadores solo conservarán el último valor ("Bob"), descartando silenciosamente los anteriores.

Uso de Comentarios

El JSON estándar no permite comentarios, aunque algunos editores sí los soportan.

{
  // Información del usuario
  "name": "Alice"
}

{
  "name": "Alicia"
}

Validación de Esquemas: Imponiendo Estructura y Tipos de Datos

JSON Schema es un estándar potente para definir y validar la estructura esperada de documentos JSON. Permite especificar:

• Campos obligatorios (`required`)
• Tipos de datos (`type`: cadena, número, booleano, objeto, arreglo, nulo)
• Formatos de cadena (`format`: correo electrónico, uuid, fecha y hora, etc.)
• Coincidencia de patrones para cadenas de texto (`pattern`)
• Rangos numéricos (`mínimo`, `máximo`)
• Validación de longitud y elementos en arreglos (`minItems`, `maxItems`, `items`)
• Validación anidada para objetos y arreglos
• Restricciones de enumeración (`enum`)

Ejemplo: Esquema de Usuario (Borrador-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
}

Lo que esto implica:

• El ID debe ser una cadena UUID válida.
• el nombre debe ser una cadena no vacía.
• el correo electrónico debe seguir el formato estándar de email.
• is_active (opcional) debe ser un valor booleano.
• No se permiten propiedades distintas a las definidas anteriormente.

Ejemplo Real: Validación de Respuestas de la API de Stripe

Supongamos que recibes respuestas en JSON de la API de Stripe (por ejemplo, PaymentIntent). La validación de esquemas garantiza que nunca proceses datos incompletos o con tipos incorrectos.

{
  "type": "object",
  "properties": {
    "id":      { "type": "string", "pattern": "^pi_" },
    "object":  { "type": "string", "const": "intención_de_pago" },
    "amount":  { "type": "integer", "minimum": 1 },
    "currency":{ "type": "string", "minLength": 3, "maxLength": 3 },
    "status":  { "type": "string", "enum": [
      "requiere_método_de_pago",
      "requiere_confirmación",
      "procesando",
      "exitoso",
      "cancelado"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• el ID debe comenzar con "pi_"
• el objeto debe ser siempre "payment_intent"
• la cantidad debe ser un número entero mayor o igual a 1
• la moneda debe ser una cadena de tres letras (por ejemplo, "usd", "eur")
• el estado debe ser uno de los valores especificados

Beneficios

• Detección temprana de errores: Identifica cambios críticos en la API o datos incompletos antes de que afecten tu lógica de negocio.
• Pruebas Automatizadas: Utiliza esquemas en pipelines CI/CD para validar respuestas reales y simuladas.
• Consistencia entre equipos: Estandariza los contratos de datos entre el frontend, backend y APIs de terceros.

Una validación adecuada de JSON, que abarca tanto la sintaxis como el esquema, previene errores sutiles, garantiza las mejores prácticas y protege tus aplicaciones contra entradas malformadas o maliciosas. Ya sea en archivos de configuración, cargas útiles de API o mensajería entre servicios, una validación sólida es fundamental para los sistemas de software modernos.

Privacidad y Seguridad

Todas las validaciones y comprobaciones de esquema se ejecutan localmente en tu navegador. Ningún dato se sube ni se registra. Tu JSON permanece completamente privado.

Ejemplos de Código para Validación de JSON

Descubre cómo validar JSON en diversos lenguajes de programación utilizando bibliotecas integradas o frameworks populares. Estos ejemplos muestran tanto la validación de sintaxis como la validación de esquemas.

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)
  }
}

Acerca de esta herramienta