JSON Validacija

Što je JSON validacija?

JSON (JavaScript Object Notation) je široko prihvaćen, lagani format za razmjenu podataka, dizajniran da bude i čitljiv ljudima i jednostavan za obradu i generiranje računala. Njegova glavna svrha je predstavljanje strukturiranih podataka—objekata, nizova, stringova, brojeva, logičkih vrijednosti i null vrijednosti—na način neovisan o programskom jeziku.

Validacija JSON-a je proces programske provjere da JSON dokument bude ispravan kako sintaktički, tako i strukturno. To uključuje provjeru dva glavna aspekta:

• Sintaktička validacija: Osiguravanje da sirovi tekst slijedi formalnu gramatiku definiranu ECMA-404 JSON specifikacijom. Parserski alati u većini modernih programskih jezika (npr. JSON.parse() u JavaScriptu, json.loads() u Pythonu, JSONDecoder u Javi) očekuju valjanu sintaksu i bacit će pogreške ako je unos neispravan.
• Strukturna (Shema) Validacija: Osim sintakse, validacija sheme provjerava odgovara li JSON podatak očekivanoj strukturi, uključujući tipove podataka, obavezna svojstva, ograničenja vrijednosti te ugniježđene objekte i nizove. Validacija sheme obično se provodi pomoću JSON Sheme, koja definira pravila za važeće podatke.

Zašto provjeravati valjanost JSON-a?

Validacija JSON-a je ključna kad god se podaci serijaliziraju za prijenos, pohranu ili međuservisnu komunikaciju. Glavni razlozi uključuju:

• Prevencija pogrešaka: Otkrivajte i prijavljujte sintaksne pogreške (npr. nedostajući zarezi, nepodudarni zagrade, nelegalni znakovi) rano—prije nego što pokušate obraditi podatke.
• Integritet i sigurnost podataka: Odbacujte neispravne ili zlonamjerne JSON podatke kako biste spriječili padove poslužitelja, napade ubrizgavanjem koda i oštećenje podataka.
• Sigurnost tipova: Primijenite strogu tipizaciju — osiguravajući, na primjer, da polje koje se očekuje kao boolean ne bude poslano kao string, ili da UUID-ovi, e-mailovi i brojevi budu u ispravnom formatu.
• Kompatibilnost između jezika: Osigurajte da JSON generiran u jednom okruženju (npr. Node.js) bude sigurno upotrebljiv u drugom (npr. Python, Go, Java), izbjegavajući pogreške pri serijalizaciji i deserijalizaciji.
• Održavanje i robusnost: Validirane strukture podataka poboljšavaju praćenje i smanjuju rizik od teško otkrivenih pogrešaka u konfiguracijskim datotekama, zapisnicima ili API zahtjevima/odgovorima.
• Privatnost i sigurnost: Validacija se može izvesti u potpunosti na strani klijenta (u pregledniku), čime se sprječava da sirovi ili osjetljivi podaci napuste uređaj korisnika tijekom validacije.

Česte pogreške u provjeri valjanosti JSON-a (s detaljnim primjerima)

Ključevi bez navodnika

Svi ključevi u JSON objektima moraju biti nizovi znakova u dvostrukim navodnicima.

{ ime: "Alice" }

{ "name": "Alisa" }

Mnogi formati slični JSON-u (npr. JavaScript objektni literali) dopuštaju ključeve bez navodnika, ali standardni JSON to ne omogućava.

Jednostruki navodnici

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

{ 'name': 'Bob' }

{ "name": "Bob" }

Korištenje jednostrukih navodnika uzrokovat će pogreške parsera u svim sukladnim JSON knjižnicama.

Zarezi na kraju

Bez zareza nakon posljednje stavke u objektu ili polju.

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

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

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

Nepravilno ispuštanje znakova

Navodnici i posebni znakovi unutar nizova moraju biti escapirani pomoću obrnutog kosa crte (backslash).

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

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

Ostali sekvencijski znakovi za bijeg uključuju \\ za obrnutu kosu crtu, \n za novi red i \t za tabulator.

Pogrešne vrste podataka

Za brojeve, logičke vrijednosti ili null ne smiju se koristiti nizovi.

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

{ "omogućeno": true, "broj": 10 }

JSON razlikuje između logičkih vrijednosti, brojeva i nizova znakova—osigurajte upotrebu ispravnog tipa.

Neprimitivni ključevi

Ključevi JSON objekta uvijek moraju biti nizovi znakova; ne možete koristiti brojeve, booleove vrijednosti ili druge tipove kao ključeve.

{ 123: "abc" }

{ "123": "abc" }

Duplicirane ključne riječi

Iako su duplicirani ključevi dopušteni JSON specifikacijom, često su izvor grešaka u programiranju.

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

Većina parsirača zadržat će samo posljednju vrijednost ("Bob"), tiho odbacujući ranije.

Korištenje komentara

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

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

{
  "name": "Alice"
}

Provjera sheme: Nametanje strukture i vrsta podataka

JSON Schema je moćan standard za definiranje i provjeru očekivane strukture JSON dokumenata. Omogućuje vam da navedete:

• Obavezna polja (`required`)
• Tipovi podataka (`type`: stringa, broj, logička vrijednost, objekt, niz, null)
• Formati nizova (`format`: email, uuid, datum-vrijeme, itd.)
• Usklađivanje uzoraka za nizove (`pattern`)
• Brojevi u rasponu (`minimum`, `maksimum`)
• Provjera duljine polja i valjanosti stavki (`minItems`, `maxItems`, `items`)
• Ugniježđena validacija za objekte i nizove
• Ograničenja tipa Enum (`enum`)

Primjer: Korisnička shema (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
}

Što ovo nameće:

• id mora biti valjani UUID niz.
• ime mora biti niz koji nije prazan.
• e-pošta mora biti u standardnom formatu e-pošte.
• is_active (neobavezno) mora biti logička vrijednost (boolean).
• Nisu dopuštene druge značajke osim onih definiranih gore.

Stvarni Primjer: Validacija Stripe API Odgovora

Pretpostavimo da primate JSON odgovore od 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": [
      "zahtijeva_način_plaćanja",
      "zahtijeva_potvrdu",
      "obrađuje_se",
      "uspješno",
      "otkazano"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• ID mora započeti sa "pi_"
• objekt mora uvijek biti "payment_intent"
• iznos mora biti cijeli broj veći ili jednak 1
• valuta mora biti niz od tri slova (npr. "usd", "eur")
• status mora biti jedna od navedenih vrijednosti

Prednosti

• Rano otkrivanje pogrešaka: Uočite kritične promjene u API-ju ili nepotpune podatke prije nego što dosegnu vašu poslovnu logiku.
• Automatizirano testiranje: Koristite sheme u CI/CD procesima za provjeru stvarnih i simuliranih odgovora.
• Dosljednost između timova: Standardizirajte podatkovne ugovore između frontend, backend i API-ja trećih strana.

Ispravna validacija JSON-a—obuhvaćajući i sintaksu i shemu—sprječava suptilne pogreške, provodi najbolje prakse i štiti vaše aplikacije od neispravnih ili štetnih podataka. Bilo da se koristi u konfiguracijskim datotekama, API zahtjevima ili internim porukama između servisa, snažna validacija ključna je za moderne softverske sustave.

Privatnost i sigurnost

Sva provjera valjanosti i šema obavlja se lokalno u vašem pregledniku. Nijedan podatak nije učitan niti zabilježen. Vaš JSON ostaje potpuno privatan.

Primjeri koda za validaciju JSON-a

Pogledajte kako validirati JSON u različitim programskim jezicima koristeći ugrađene biblioteke ili popularne okvire. Ovi primjeri pokazuju kako provjeriti ispravnost sintakse i validaciju šema.

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