Validator JSON

Ce este validarea JSON?

JSON (JavaScript Object Notation) este un format ușor, folosit pe scară largă pentru schimbul de date, conceput să fie atât ușor de citit pentru oameni, cât și simplu de analizat și generat de către mașini. Scopul său principal este să reprezinte date structurate — obiecte, array-uri, șiruri de caractere, numere, valori booleene și valori nule — într-un mod independent de limbaj.

Validarea JSON este procesul de verificare programatică a faptului că un document JSON este corect atât din punct de vedere sintactic, cât și structural. Acest lucru presupune verificarea a două aspecte principale:

• Validare Sintactică: Asigurarea că textul brut respectă gramatica formală definită de specificația ECMA-404 JSON. Parselele din majoritatea limbajelor de programare moderne (de exemplu, JSON.parse() în JavaScript, json.loads() în Python, JSONDecoder în Java) așteaptă o sintaxă validă și vor genera erori dacă intrarea este incorectă.
• Validare Structurală (Schema): Dincolo de sintaxă, validarea schemei verifică dacă datele JSON respectă o structură așteptată, inclusiv tipurile de date, proprietățile obligatorii, restricțiile asupra valorilor și obiectele/tablourile imbricate. Validarea schemei se realizează de obicei folosind JSON Schema, care definește reguli pentru ceea ce este considerat date valide.

De ce să validăm JSON-ul?

Validarea JSON este esențială oriunde datele sunt serializate pentru transmisie, stocare sau comunicare între servicii. Motivele principale includ:

• Prevenirea erorilor: Detectați și raportați erorile de sintaxă (de exemplu, virgule lipsă, paranteze neînchise, caractere ilegale) din timp — înainte de a încerca să procesați datele.
• Integritatea și securitatea datelor: Respingeți payload-urile JSON nevalide sau malițioase, prevenind astfel blocările backend, atacurile de tip injectare și coruperea datelor.
• Siguranța tipurilor: Aplică tipare stricte—asigurându-te, de exemplu, că un câmp ce trebuie să fie boolean nu este trimis ca șir de caractere, sau că UUID-urile, adresele de email și numerele respectă formatul corect.
• Compatibilitate Inter-limbaj: Asigură că JSON-ul generat într-un mediu (de exemplu, Node.js) poate fi utilizat în siguranță într-altul (de exemplu, Python, Go, Java), evitând erorile de serializare/deserializare.
• Mentenabilitate și Robusteză: Structurile de date validate îmbunătățesc trasabilitatea și reduc riscul apariției erorilor dificil de depistat în fișiere de configurare, jurnale sau cereri/răspunsuri API.
• Confidențialitate și securitate: Validarea poate fi realizată integral pe partea clientului (în browser), prevenind astfel transmiterea datelor brute sau sensibile de pe dispozitivul utilizatorului în vederea validării.

Erori comune de validare JSON (cu exemple detaliate)

Chei fără ghilimele

Toate cheile din obiectele JSON trebuie să fie șiruri între ghilimele duble.

{ name: "Alice" }

{ "name": "Alice" }

Multe formate asemănătoare JSON-ului (de exemplu, literalii de obiect în JavaScript) permit chei fără ghilimele, însă JSON-ul standard nu acceptă acest lucru.

Ghilimele simple

Șirurile JSON trebuie să folosească doar ghilimele duble; ghilimelele simple nu sunt permise.

{ 'name': 'Bob' }

{ "name": "Bob" }

Folosirea ghilimelelor simple va duce la erori de analiză în toate bibliotecile JSON conforme.

Virgule finale

Fără virgulă la sfârșitul ultimului element într-un obiect sau tablou.

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

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

Virgulele finale pot funcționa în JavaScript, dar nu sunt acceptate în parser-ele JSON stricte.

Escapare incorectă a caracterelor

Ghilimelele și caracterele speciale din interiorul șirurilor de caractere trebuie să fie scăpate folosind o bară oblică inversă.

{ "quote": "Tom a spus \"hello\"" }

{ "quote": "Tom a spus \"salut\"" }

Alte secvențe de escape includ \\ pentru backslash, \n pentru linii noi și \t pentru taburi.

Tipuri de date incorecte

Șirurile de caractere nu ar trebui utilizate pentru numere, valori booleene sau null.

{ "enabled": "adevărat", "count": "10" }

{ "activat": true, "numar": 10 }

JSON face distincție între valori booleene, numere și șiruri de caractere — asigură-te că folosești tipul corect.

Chei Non-Primitive

Cheile obiectelor JSON trebuie să fie întotdeauna șiruri de caractere; nu poți folosi numere, valori booleene sau alte tipuri ca și chei.

{ 123: "abc" }

{ "123": "abc" }

Chei Duplicat

Deși sunt permise de specificația JSON, cheile duplicate sunt o sursă frecventă de erori.

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

Majoritatea analizatorilor vor păstra doar ultima valoare („Bob”), ignorând silențios valorile anterioare.

Utilizarea comentariilor

JSON-ul standard nu permite comentarii, deși unele editoare le acceptă.

{
  // Informații utilizator
  "name": "Alice"
}

{
  "name": "Alice"
}

Validarea Schemei: Impunerea Structurii și Tipurilor de Date

JSON Schema este un standard puternic pentru definirea și validarea structurii așteptate a documentelor JSON. Îți permite să specifici:

• Câmpuri obligatorii (`required`)
• Tipuri de date (`type`: șir de caractere, număr, boolean, obiect, matrice, nul)
• Formate de șiruri de caractere (`format`: email, uuid, dată-timp, etc.)
• Potrivirea șabloanelor pentru șiruri de caractere (`pattern`)
• Intervale numerice (`minim`, `maxim`)
• Lungimea și validarea elementelor în array (`minItems`, `maxItems`, `items`)
• Validare încorporată pentru obiecte și array-uri
• Constrângeri de tip Enum (`enum`)

Exemplu: Schema Utilizator (Draft-07)

{
  "type": "obiect",
  "properties": {
    "id":    { "type": "șir", "format": "uuid" },
    "name":  { "type": "șir", "minLength": 1 },
    "email": { "type": "șir", "format": "email" },
    "is_active": { "type": "boolean" }
  },
  "required": ["id", "name", "email"],
  "additionalProperties": false
}

Ce impune acest lucru:

• ID-ul trebuie să fie un șir UUID valid.
• numele trebuie să fie un șir de caractere nenul.
• emailul trebuie să respecte formatul standard al unui email.
• is_active (opțional) trebuie să fie un boolean.
• Nu sunt permise alte proprietăți în afară de cele definite mai sus.

Exemplu Practic: Validarea Răspunsurilor API Stripe

Să presupunem că primești răspunsuri JSON de la API-ul Stripe (de exemplu, PaymentIntent). Validarea schemelor poate asigura că nu procesezi niciodată date incomplete sau de tip incorect.

{
  "type": "obiect",
  "properties": {
    "id":      { "type": "șir", "pattern": "^pi_" },
    "object":  { "type": "șir", "const": "payment_intent" },
    "amount":  { "type": "întreg", "minimum": 1 },
    "currency":{ "type": "șir", "minLength": 3, "maxLength": 3 },
    "status":  { "type": "șir", "enum": [
      "necesită_metodă_de_plată",
      "necesită_confirmare",
      "în_procesare",
      "finalizat_cu_succes",
      "anulat"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• ID-ul trebuie să înceapă cu "pi_"
• obiectul trebuie să fie întotdeauna "payment_intent"
• suma trebuie să fie un număr întreg mai mare sau egal cu 1
• moneda trebuie să fie un șir de trei litere (de exemplu, "usd", "eur")
• starea trebuie să fie una dintre valorile specificate

Beneficii

• Detectare timpurie a erorilor: Identifică modificările critice ale API-ului sau datele incomplete înainte ca acestea să ajungă la logica afacerii tale.
• Testare Automată: Utilizează scheme în pipeline-urile CI/CD pentru a valida răspunsurile reale și simulate.
• Consistență între echipe: Standardizați contractele de date între frontend, backend și API-urile terților.

Validarea corectă a JSON—acoperind atât sintaxa, cât și schema—previne erorile subtile, impune cele mai bune practici și securizează aplicațiile împotriva intrărilor incorecte sau malițioase. Indiferent dacă este utilizată în fișiere de configurare, payloads API sau mesagerie între servicii, o validare robustă este esențială pentru sistemele software moderne.

Confidențialitate și Securitate

Toate verificările de validare și de schemă se efectuează local, în browserul tău. Niciun fel de date nu sunt încărcate sau înregistrate. JSON-ul tău rămâne complet privat.

Exemple de cod pentru validarea JSON-ului

Vezi cum să validezi JSON în diverse limbaje de programare folosind biblioteci încorporate sau framework-uri populare. Aceste exemple demonstrează atât validarea sintaxei, cât și validarea schemelor JSON.

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

Despre acest instrument