JSON Validaciju

Šta je JSON validacija?

JSON (JavaScript Object Notation) je široko prihvaćen, lagani format za razmenu podataka, dizajniran tako da bude čitljiv ljudima i jednostavan za mašinsku obradu i generisanje. Njegova osnovna svrha je predstavljanje strukturiranih podataka — objekata, nizova, stringova, brojeva, booleanskih vrednosti i null vrednosti — na način nezavistan od programskog jezika.

Validacija JSON-a je proces programske provere da li je JSON dokument ispravan i sintaksno i strukturno. To podrazumeva proveru dva glavna aspekta:

• Sintaksna validacija: Osiguravanje da sirovi tekst prati formalnu gramatiku definisanu ECMA-404 JSON specifikacijom. Parsers u većini savremenih programskih jezika (npr. JSON.parse() u JavaScriptu, json.loads() u Pythonu, JSONDecoder u Javi) očekuju važeću sintaksu i javiće greške ako je ulazni podatak nepravilno formiran.
• Strukturna (šema) validacija: Pored sintakse, validacija šeme proverava da li JSON podaci odgovaraju očekivanoj strukturi, uključujući tipove podataka, obavezna polja, ograničenja vrednosti i ugneždene objekte/nizove. Validacija šeme se obično vrši korišćenjem JSON šeme, koja definiše pravila za validne podatke.

Zašto validirati JSON?

Validacija JSON-a je ključna gde god se podaci serijalizuju za prenos, skladištenje ili komunikaciju između servisa. Glavni razlozi uključuju:

• Prevencija grešaka: Otkrivajte i prijavljujte sintaksne greške (npr. nedostajuće zareze, nepodudarne zagrade, nedozvoljene karaktere) na vreme — pre nego što pokušate da obradite podatke.
• Integritet podataka i sigurnost: Odbacujte neispravne ili zlonamerne JSON poruke, čime se sprečavaju kvarovi na serverskoj strani, injekcione napade i oštećenje podataka.
• Tipna sigurnost: Sprovodite strogu tipizaciju—osiguravajući, na primer, da polje koje se očekuje kao boolean ne bude poslato kao string, ili da UUID-ovi, email adrese i brojevi slede pravilni format.
• Višejezična kompatibilnost: Osigurajte da JSON kreiran u jednom okruženju (npr. Node.js) bude bezbedno upotrebljiv u drugom (npr. Python, Go, Java), izbegavajući greške prilikom serijalizacije i deserijalizacije.
• Održavanje i Robusnost: Validirane strukture podataka poboljšavaju praćenje i smanjuju rizik od teško otklonjivih grešaka u konfiguracionim fajlovima, logovima ili API zahtevima/odgovorima.
• Privatnost i sigurnost: Validacija se može izvršiti u potpunosti na strani klijenta (u pregledaču), čime se sprečava da sirovi ili osetljivi podaci napuste uređaj korisnika radi validacije.

Uobičajene Greške u Validaciji JSON-a (sa Detaljnim Primerima)

Ključevi bez navodnika

Svi ključevi u JSON objektima moraju biti stringovi sa dvostrukim navodnicima.

{ name: "Alisa" }

{ "name": "Alisa" }

Mnogi formati slični JSON-u (na primer, JavaScript objekti) dozvoljavaju ključeve bez navodnika, ali standardni JSON to ne podržava.

Jednostruki navodnici

JSON stringovi moraju koristiti samo dvostruke navodnike; jednostruki navodnici nisu dozvoljeni.

{ 'name': 'Bob' }

{ "name": "Bob" }

Korišćenje jednostrukih navodnika će prouzrokovati greške parsera u svim kompatibilnim JSON bibliotekama.

Zarezi na kraju

Bez zareza na kraju poslednjeg elementa u objektu ili nizu.

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

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

Zarezi na kraju mogu raditi u JavaScriptu, ali ne i u strogim JSON parserima.

Nepravilno ispisivanje karaktera

Navodnici i posebni karakteri unutar stringova moraju biti escapovani pomoću obrnutog kosa crte.

{ "quote": "Tom je rekao \"zdravo\"" }

{ "quote": "Tom je rekao \"zdravo\"" }

Ostale sekvence za bekstejdž uključuju \\ za kosu crtu, \n za nove redove i \t za tabove.

Pogrešni tipovi podataka

Niske vrednosti ne bi trebalo koristiti za brojeve, booleove vrednosti ili null.

{ "enabled": "tačno", "count": "10" }

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

JSON pravi razliku između boolean vrednosti, brojeva i stringova—pobrinite se da se koristi pravi tip.

Nepretržne ključne reči

Ključevi JSON objekta moraju uvek biti stringovi; ne možete koristiti brojeve, booleane ili druge tipove kao ključeve.

{ 123: "abc" }

{ "123": "abc" }

Duplikatni ključevi

Iako je prema JSON specifikaciji dozvoljeno, duplicirani ključevi su čest izvor grešaka.

{ "name": "Алиса", "name": "Боб" }

Većina parsera će sačuvati samo poslednju vrednost ("Bob"), tiho odbacujući ranije.

Upotreba komentara

Standardni JSON ne dozvoljava komentare, iako ih neki uređivači podržavaju.

{
  // Informacije o korisniku
  "name": "Alisa"
}

{
  "name": "Алис"
}

Validacija Šeme: Nametanje Strukture i Tipova Podataka

JSON Schema je moćan standard za definisanje i proveru očekivane strukture JSON dokumenata. Omogućava vam da precizirate:

• Obavezna polja (`required`)
• Tipovi podataka (`type`: stringa, brojeva, booleana, objekta, niza, null)
• Formati nizova (`format`: imejl, uuid, datum-vreme, itd.)
• Usklađivanje obrazaca za stringove (`pattern`)
• Opsezi brojeva (`minimum`, `maksimum`)
• Validacija dužine niza i stavki (`minItems`, `maxItems`, `items`)
• Ugnježdena validacija za objekte i nizove
• Ograničenja tipa enumeracije (`enum`)

Primer: Korisnička šema (Nacrt-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}

Ono što ovo nameće:

• ID mora biti važeći UUID niz.
• ime mora biti ne-prazan string.
• e-pošta mora odgovarati standardnom formatu e-pošte.
• is_active (opciono) mora biti logička vrednost.
• Nisu dozvoljene druge nekretnine osim onih definisanih gore.

Praktični Primer: Validacija Odgovora Stripe API-ja

Pretpostavimo da primate JSON odgovore sa Stripe API-ja (npr. PaymentIntent). Validacija šeme može osigurati da nikada ne obrađujete nepotpune ili pogrešno tipizirane podatke.

{
  "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": [
      "zahteva_načinu_placanja",
      "zahteva_potvrdu",
      "u_obradi",
      "uspešno",
      "otkazano"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• id mora početi sa "pi_"
• objekat mora uvek biti "payment_intent"
• iznos mora biti ceo broj veći ili jednak 1
• valuta mora biti niz od tri slova (npr. „usd“, „eur“)
• status mora biti jedna od navedenih vrednosti

Prednosti

• Rano otkrivanje grešaka: Otkrivajte kritične promene u API-ju ili nepotpune podatke pre nego što utiču na vašu poslovnu logiku.
• Automatizovano testiranje: Koristite šeme u CI/CD procesima za proveru stvarnih i simuliranih odgovora.
• Doslednost između timova: Standardizujte podatkovne ugovore između frontend-a, backend-a i API-ja trećih strana.

Ispravno validiranje JSON-a — koje obuhvata i sintaksu i šemu — sprečava suptilne greške, primenjuje najbolje prakse i štiti vaše aplikacije od neispravnih ili zlonamernih ulaza. Bilo da se koristi u konfiguracionim fajlovima, API podacima ili interservisnoj komunikaciji, robusna validacija predstavlja temelj modernih softverskih sistema.

Privatnost i bezbednost

Sve provere validacije i šeme izvode se lokalno u vašem pregledaču. Nijedni podaci nisu otpremljeni niti zabeleženi. Vaš JSON ostaje potpuno privatан.

Primeri koda za validaciju JSON-a

Pogledajte kako validirati JSON u različitim programskim jezicima koristeći ugrađene biblioteke ili popularne frejmvorke. Ovi primeri prikazuju kako validaciju sintakse, tako i validaciju prema šemi.

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

O ovom alatu