Validatore JSON

Cos'è la convalida JSON?

JSON (JavaScript Object Notation) è un formato di scambio dati leggero e ampiamente utilizzato, progettato per essere sia leggibile dall'uomo che facile da analizzare e generare per le macchine. Il suo scopo principale è rappresentare dati strutturati — oggetti, array, stringhe, numeri, booleani e valori nulli — in modo indipendente dal linguaggio.

La validazione JSON è il processo di verifica programmata che un documento JSON sia corretto sia dal punto di vista sintattico che strutturale. Questo comporta il controllo di due aspetti principali:

• Validazione Sintattica: Garantire che il testo grezzo segua la grammatica formale definita dalla specifica JSON ECMA-404. I parser nelle più moderne lingue di programmazione (ad esempio, JSON.parse() in JavaScript, json.loads() in Python, JSONDecoder in Java) richiedono una sintassi valida e genereranno errori se l'input è malformato.
• Validazione Strutturale (Schema): Oltre alla sintassi, la convalida dello schema verifica che i dati JSON corrispondano a una struttura prevista, compresi i tipi di dati, le proprietà obbligatorie, i vincoli sui valori e gli oggetti/array nidificati. La convalida dello schema viene generalmente eseguita usando JSON Schema, che definisce regole per identificare i dati considerati validi.

Perché convalidare JSON?

La convalida del JSON è fondamentale ovunque i dati vengano serializzati per la trasmissione, l'archiviazione o la comunicazione tra servizi. I motivi principali sono:

• Prevenzione degli Errori: Rileva e segnala tempestivamente errori di sintassi (ad esempio, virgole mancanti, parentesi non abbinate, caratteri non consentiti) prima di procedere all'elaborazione dei dati.
• Integrità e Sicurezza dei Dati: Rifiuta payload JSON malformati o dannosi, aiutando a prevenire crash del backend, attacchi di injection e corruzione dei dati.
• Sicurezza del Tipo: Applica un tipaggio rigoroso—garantendo, ad esempio, che un campo previsto come booleano non venga inviato come stringa, e che UUID, email o numeri rispettino il formato corretto.
• Compatibilità tra Lingue Diverse: Garantire che i JSON generati in un ambiente (es. Node.js) siano utilizzabili in modo sicuro in un altro (es. Python, Go, Java), evitando errori di serializzazione/deserializzazione.
• Manutenibilità e Robustezza: Le strutture dati validate migliorano la tracciabilità e riducono il rischio di errori difficili da diagnosticare nei file di configurazione, nei log e nelle richieste/risposte API.
• Privacy e Sicurezza: La convalida può essere eseguita interamente lato client (nel browser), evitando che dati grezzi o sensibili lascino il dispositivo dell’utente per la validazione.

Errori Comuni di Validazione JSON (con Esempi Dettagliati)

Chiavi senza virgolette

Tutte le chiavi negli oggetti JSON devono essere stringhe racchiuse tra virgolette doppie.

{ nome: "Alice" }

{ "name": "Alice" }

Molti formati simili al JSON (ad esempio, i letterali di oggetti JavaScript) consentono chiavi non tra virgolette, ma il JSON standard non lo permette.

Virgolette Singole

Le stringhe JSON devono utilizzare esclusivamente le virgolette doppie; le virgolette singole non sono consentite.

{ 'name': 'Bob' }

{ "name": "Bob" }

L'uso delle virgolette singole provocherà errori di parsing in tutte le librerie JSON conformi.

Virgole Finali

Nessuna virgola finale dopo l'ultimo elemento in un oggetto o array.

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

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

Le virgole finali possono funzionare in JavaScript, ma non nei parser JSON rigorosi.

Scorretta Escape dei Caratteri

Le virgolette e i caratteri speciali all'interno delle stringhe devono essere preceduti da una barra rovesciata (backslash).

{ "quote": "Tom ha detto \"ciao\"" }

{ "quote": "Tom ha detto \"ciao\"" }

Altre sequenze di escape includono \\ per la barra rovesciata, \n per le nuove righe, e \t per le tabulazioni.

Tipi di dati errati

Le stringhe non devono essere utilizzate per numeri, valori booleani o null.

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

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

JSON distingue tra booleani, numeri e stringhe: assicurati di utilizzare il tipo corretto.

Chiavi Non Primitivi

Le chiavi degli oggetti JSON devono sempre essere stringhe; non è possibile utilizzare numeri, booleani o altri tipi come chiavi.

{ 123: "abc" }

{ "123": "abc" }

Chiavi Duplicate

Sebbene consentite dalle specifiche JSON, le chiavi duplicate sono una causa comune di errori.

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

La maggior parte degli parser conserverà solo l'ultimo valore ("Bob"), scartando silenziosamente quelli precedenti.

Utilizzo dei Commenti

Il JSON standard non consente commenti, anche se alcuni editor li supportano.

{
  // Informazioni utente
  "name": "Alice"
}

{
  "name": "Alice"
}

Validazione dello Schema: Applicare la Struttura e i Tipi di Dati

JSON Schema è uno standard potente per definire e convalidare la struttura prevista dei documenti JSON. Ti consente di specificare:

• Campi obbligatori (`required`)
• Tipi di dati (`type`: stringa, numero, booleano, oggetto, array, nullo)
• Formati di stringa (`format`: email, uuid, data-ora, ecc.)
• Corrispondenza di pattern per stringhe (`pattern`)
• Intervalli numerici (`minimo`, `massimo`)
• Lunghezza dell'array e convalida degli elementi (`minItems`, `maxItems`, `items`)
• Validazione nidificata per oggetti e array
• Vincoli di enumerazione (`enum`)

Esempio: Schema Utente (Bozza-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
}

Cosa garantisce questo:

• l'ID deve essere una stringa UUID valida.
• il nome deve essere una stringa non vuota.
• l'email deve corrispondere al formato standard di un indirizzo email.
• is_active (opzionale) deve essere un valore booleano.
• Non sono consentite proprietà diverse da quelle definite sopra.

Esempio Pratico: Validazione delle Risposte dell'API di Stripe

Supponiamo che tu riceva risposte JSON dall'API di Stripe (ad esempio, PaymentIntent). La validazione dello schema può garantire che tu non elabori mai dati incompleti o con tipi errati.

{
  "type": "object",
  "properties": {
    "id":      { "type": "string", "pattern": "^pi_" },
    "object":  { "type": "string", "const": "payment_intent" },
    "amount":  { "type": "integer", "minimum": 1 },
    "currency":{ "type": "string", "minLength": 3, "maxLength": 3 },
    "status":  { "type": "string", "enum": [
      "richiede_metodo_pagamento",
      "richiede_conferma",
      "in_elaborazione",
      "riuscito",
      "annullato"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• l'ID deve iniziare con "pi_"
• l'oggetto deve sempre essere "payment_intent"
• la quantità deve essere un numero intero maggiore o uguale a 1
• la valuta deve essere una stringa di tre lettere (esempio: "usd", "eur")
• lo stato deve essere uno dei valori specificati

Vantaggi

• Rilevamento Precoce degli Errori: Individua modifiche API critiche o dati incompleti prima che influenzino la tua logica di business.
• Test Automatizzati: Utilizza schemi nei pipeline CI/CD per convalidare risposte reali e simulate.
• Coerenza tra team: Standardizza i contratti dei dati tra frontend, backend e API di terze parti.

La convalida JSON corretta—che copre sia la sintassi che lo schema—previene bug nascosti, applica le migliori pratiche e protegge le tue applicazioni da input malformati o malevoli. Sia che venga utilizzata in file di configurazione, payload API o messaggi tra servizi, una convalida solida è fondamentale per i sistemi software moderni.

Privacy e Sicurezza

Tutte le validazioni e i controlli dello schema vengono eseguiti localmente nel tuo browser. Nessun dato viene caricato o registrato. Il tuo JSON rimane completamente privato.

Esempi di Codice per la Validazione JSON

Scopri come convalidare JSON in diversi linguaggi di programmazione utilizzando librerie integrate o framework popolari. Questi esempi mostrano sia la convalida della sintassi che quella dello schema.

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

Informazioni su questo strumento