Validador JSON

Què és la validació JSON?

JSON (JavaScript Object Notation) és un format lleuger d'intercanvi de dades àmpliament adoptat, dissenyat per ser tant fàcil de llegir per humans com senzill de processar i generar per màquines. El seu propòsit principal és representar dades estructurades—objectes, arrays, cadenes de text, nombres, booleans i valors nuls—d'una manera independent del llenguatge de programació.

La validació JSON és el procés de verificar programàticament que un document JSON sigui correcte tant sintàcticament com estructuralment. Això implica comprovar dos aspectes principals:

• Validació sintàctica: Garantir que el text en brut segueixi la gramàtica formal definida per l'especificació JSON ECMA-404. Els parsejadors en la majoria de llenguatges de programació moderns (per exemple, JSON.parse() en JavaScript, json.loads() en Python, JSONDecoder en Java) esperen una sintaxi vàlida i generaran errors si l'entrada està mal formatejada.
• Validació estructural (Schema): Més enllà de la sintaxi, la validació d’esquema comprova que les dades JSON coincideixin amb una estructura esperada, incloent tipus de dades, propietats requerides, restriccions de valors i objectes/matrixos aniuats. La validació d’esquema normalment es fa utilitzant JSON Schema, que defineix regles sobre què es considera dada vàlida.

Per què validar JSON?

La validació de JSON és fonamental sempre que les dades es serialitzen per a transmissió, emmagatzematge o comunicació entre serveis. Algunes raons clau inclouen:

• Prevenció d'errors: Detectar i informar errors de sintaxi (per exemple, comes desaparegudes, parèntesis sense tancar, caràcters il·legals) de manera precoç—abans d'intentar processar les dades.
• Integritat i Seguretat de les Dades: Rebutja càrregues JSON malformades o malicioses, ajudant a prevenir fallades del servidor, atacs d’injecció o corrupció de dades.
• Seguretat de Tipus: Apliqueu tipificació estricta—garantint, per exemple, que un camp esperat com a booleà no es valori com a cadena, o que els UUIDs, correus electrònics o números segueixin el format correcte.
• Compatibilitat entre llenguatges: garanteix que el JSON generat en un entorn (per exemple, Node.js) sigui segurament utilitzable en un altre (per exemple, Python, Go, Java), evitant errors de serialització i deserialització.
• Mantenibilitat i Robustesa: Les estructures de dades validades milloren la traçabilitat i redueixen el risc d’errors difícils de depurar en fitxers de configuració, registres o sol·licituds/respostes d’API.
• Privacitat i Seguretat: La validació es pot realitzar completament al client (al navegador), evitant que dades en brut o sensibles surtin del dispositiu de l'usuari per a la seva validació.

Errors comuns de validació JSON (amb exemples detallats)

Claus sense cometes

Totes les claus en objectes JSON han de ser cadenes entrecomillades amb cometes dobles.

{ name: "Alice" }

{ "name": "Alícia" }

Molts formats similars a JSON (per exemple, literals d'objectes de JavaScript) permeten claus sense cometes, però el JSON estàndard no ho permet.

Cometes simples

Les cadenes JSON han d'utilitzar només cometes dobles; no es permeten les cometes simples.

{ 'name': 'Bob' }

{ "name": "Bob" }

L’ús de cometes simples provocarà errors d’analitzador en totes les biblioteques JSON compatibles.

Cometes finals

No cal posar coma després de l’últim element d’un objecte o d’un array.

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

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

Les comes finals poden funcionar a JavaScript, però no en parsejadors JSON estrictes.

Escapament incorrecte de caràcters

Les cometes i els caràcters especials dins de les cadenes han de ser escapats amb una barra invertida.

{ "quote": "En Tom va dir \"hola\"" }

{ "quote": "En Tom va dir \"hola\"" }

Altres seqüències d’escapament inclouen \\ per a la contrabarra, \n per a salts de línia, i \t per a tabulacions.

Tipus de dades incorrectes

No s'han d'utilitzar cadenes de text per a nombres, booleans o valors nuls.

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

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

JSON distingeix entre booleans, nombres i cadenes—assegura't d'utilitzar el tipus correcte.

Claus No Primitives

Les claus d'un objecte JSON sempre han de ser cadenes; no es poden utilitzar números, booleans ni altres tipus com a claus.

{ 123: "abc" }

{ "123": "abc" }

Claus duplicades

Tot i que està permès per la especificació JSON, les claus duplicades són una causa comuna d'errors.

{ "name": "Alice", "name": "Bob" }

La majoria d'analitzadors només conservaran l'últim valor ("Bob"), descartant silenciosament els anteriors.

Ús dels comentaris

El JSON estàndard no permet comentaris, tot i que alguns editors els suporten.

{
  // Informació de l'usuari
  "name": "Alice"
}

{
  "name": "Alicia"
}

Validació d'Esquema: Aplicació d'Estructura i Tipus de Dades

JSON Schema és un estàndard potent per definir i validar l'estructura esperada dels documents JSON. Et permet especificar:

• Camps obligatoris (`required`)
• Tipus de dades (`type`: cadena, nombre, booleà, objecte, matriu, nul)
• Formats de cadena (`format`: correu electrònic, uuid, data i hora, etc.)
• Coincidència de patrons per a cadenes de text (`pattern`)
• Interval de nombres (`mínim`, `màxim`)
• Validació de la longitud de l'array i dels elements (`minItems`, `maxItems`, `items`)
• Validació anidada per a objectes i matrius
• Restriccions d'enum (`enum`)

Exemple: Esquema d'Usuari (Draft-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
}

El que això imposa:

• l'identificador ha de ser una cadena UUID vàlida.
• el nom ha de ser una cadena no buida.
• el correu electrònic ha de seguir el format estàndard de correu.
• is_active (opcional) ha de ser un valor booleà.
• No es permeten propietats diferents de les definides anteriorment.

Exemple Pràctic: Validació de les Respostes de l'API de Stripe

Suposeu que rebeu respostes JSON de l'API de Stripe (per exemple, PaymentIntent). La validació d'esquema pot garantir que mai no processareu dades incompletes o amb tipus incorrectes.

{
  "type": "object",
  "properties": {
    "id":      { "type": "string", "pattern": "^pi_" },
    "objecte":  { "type": "string", "const": "intenpagament" },
    "quantitat":  { "type": "integer", "minimum": 1 },
    "moneda":{ "type": "string", "minLength": 3, "maxLength": 3 },
    "estat":  { "type": "string", "enum": [
      "requereix_mtode_pagament",
      "requereix_confirmaci",
      "processant",
      "exitus",
      "cancel" 
    ]}
  },
  "obligatori": ["id", "objecte", "quantitat", "moneda", "estat"],
  "propietatsAddicionals": false
}

• l'identificador ha de començar per "pi_"
• L'objecte ha de ser sempre "payment_intent"
• la quantitat ha de ser un nombre enter major o igual que 1
• la moneda ha de ser una cadena de tres lletres (p. ex., "usd", "eur")
• l'estat ha de ser un dels valors especificats

Beneficis

• Detecció primerenca d’errors: Identifica canvis crítics a l’API o dades incompletes abans que arribin a la teva lògica de negoci.
• Proves automatitzades: Utilitza esquemes en pipelines CI/CD per validar respostes reals i simulades.
• Consistència entre equips: Estandarditzeu els contractes de dades entre frontend, backend i APIs de tercers.

La validació adequada de JSON—que inclou tant la sintaxi com l'esquema—evita errors subtils, aplica les millors pràctiques i protegeix les teves aplicacions contra entrades malformades o malintencionades. Tant si s'utilitza en fitxers de configuració, com en càrregues d'API o en missatgeria entre serveis, una validació robusta és fonamental per als sistemes de programari moderns.

Privacitat i Seguretat

Totes les validacions i comprovacions d'esquemes s'executen localment al teu navegador. No s'envia ni es registra cap dada. El teu JSON es manté completament privat.

Exemples de codi per a la validació JSON

Descobreix com validar JSON en diversos llenguatges de programació utilitzant biblioteques integrades o marcs populars. Aquests exemples mostren tant la validació de sintaxi com la validació de l'esquema.

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

Sobre aquesta eina