Overovač JSON

Čo je overenie JSON?

JSON (JavaScript Object Notation) je populárny, ľahký formát na výmenu údajov, navrhnutý tak, aby bol čitateľný pre ľudí a zároveň jednoduchý na spracovanie a tvorbu pre stroje. Jeho hlavnou úlohou je reprezentovať štruktúrované dáta — objekty, polia, reťazce, čísla, logické hodnoty a null — nezávisle od programovacieho jazyka.

Overenie JSON je proces programatického overovania, či je JSON dokument syntakticky a štrukturálne správny. Zahŕňa kontrolu dvoch hlavných aspektov:

• Syntaktická validácia: Zabezpečenie, že surový text dodržiava formálnu gramatiku podľa špecifikácie ECMA-404 JSON. Parsre vo väčšine moderných programovacích jazykov (napr. JSON.parse() v JavaScripte, json.loads() v Pythone, JSONDecoder v Jave) očakávajú platnú syntax a v prípade chybného vstupu vyhodia chyby.
• Štrukturálna (schéma) validácia: Okrem syntaxe kontrola validácie schémy overuje, či JSON dáta zodpovedajú očakávanej štruktúre, vrátane typov údajov, povinných vlastností, obmedzení hodnôt a vnorených objektov/pól. Validácia schémy sa zvyčajne vykonáva pomocou JSON Schema, ktoré definuje pravidlá pre platné dáta.

Prečo overovať JSON?

Validácia JSON je kľúčová všade tam, kde sa dáta serializujú na prenos, ukladanie alebo komunikáciu medzi službami. Hlavné dôvody zahŕňajú:

• Prevencia chýb: Včasne detekujte a hláste syntaktické chyby (napr. chýbajúce čiarky, nespárované zátvorky, nepovolené znaky) ešte pred spracovaním údajov.
• Integrita a bezpečnosť dát: Odmietajte nesprávne alebo škodlivé JSON dáta, čím predchádzate pádom backendu, útokom typu injection alebo poškodeniu údajov.
• Typová bezpečnosť: Zabezpečte prísne typovanie — napríklad aby pole očakávané ako boolean nebolo odoslané ako reťazec, alebo aby UUID, e-maily či čísla mali správny formát.
• Kompatibilita medzi jazykmi: Zaručte, že JSON vytvorený v jednom prostredí (napr. Node.js) bude bezpečne spracovateľný v inom (napr. Python, Go, Java), čím sa predíde chybám pri serializácii/deserializácii.
• Udržiavateľnosť a robustnosť: Overené dátové štruktúry zlepšujú sledovateľnosť a znižujú riziko ťažko odhaliteľných chýb v konfiguračných súboroch, logoch alebo API požiadavkách/odpovediach.
• Ochrana súkromia a bezpečnosť: Overovanie môže prebiehať kompletne na strane klienta (v prehliadači), čím sa zabráni odchodu surových alebo citlivých údajov z používateľovho zariadenia na účely overenia.

Bežné chyby pri validácii JSON (s podrobnými príkladmi)

Neuvoľnené kľúče

Všetky kľúče v JSON objektoch musia byť reťazce uzavreté v dvojitých úvodzovkách.

{ name: "Alice" }

{ "name": "Alice" }

Mnohé formáty pripomínajúce JSON (napríklad literály objektov v JavaScripte) umožňujú nepoužívať úvodzovky pri kľúčoch, no štandardný JSON to neumožňuje.

Jednoduché úvodzovky

Reťazce v JSON musia používať iba dvojité úvodzovky; jednoduché úvodzovky nie sú povolené.

{ 'name': 'Bob' }

{ "name": "Bob" }

Použitie jednoduchých úvodzoviek spôsobí chyby pri spracovaní vo všetkých štandardných JSON knižniciach.

Záverečné čiarky

Za poslednou položkou v objekte alebo poli nesmie byť čiarka.

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

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

Záverečné čiarky môžu fungovať v JavaScripte, no v prísnych JSON parseroch nie.

Nesprávne escapovanie znakov

Úvodzovky a špeciálne znaky v reťazcoch musia byť escapované pomocou spätného lomítka.

{ "quote": "Tom povedal \"ahoj\"" }

{ "quote": "Tom povedal \"ahoj\"" }

Medzi ďalšie únikové sekvencie patrí \\ pre spätné lomítko, \n pre nové riadky a \t pre tabulátory.

Nesprávne dátové typy

Reťazce by sa nemali používať pre čísla, booleovské hodnoty alebo null.

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

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

JSON rozlišuje medzi booleanmi, číslami a reťazcami – uistite sa, že používate správny typ.

Neprimitívne kľúče

Kľúče v JSON objektoch musia vždy byť reťazce; nie je možné použiť čísla, booleovské hodnoty alebo iné typy ako kľúče.

{ 123: "abc" }

{ "123": "abc" }

Duplicitné kľúče

Aj keď je to podľa špecifikácie JSON povolené, duplicitné kľúče sú častým zdrojom chýb.

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

Väčšina parserov si ponechá iba poslednú hodnotu ("Bob"), pritom tiché ignorovanie predchádzajúcich hodnôt.

Používanie komentárov

Štandardný formát JSON neumožňuje komentáre, hoci niektoré editory ich podporujú.

{
  // Informácie o používateľovi
  "name": "Alice"
}

{
  "name": "Alice"
}

Validácia schémy: Zabezpečenie štruktúry a typov údajov

JSON Schema je výkonný štandard na definovanie a overovanie očakávanej štruktúry JSON dokumentov. Umožňuje vám špecifikovať:

• Povinné polia (`required`)
• Dátové typy (`type`: reťazec, číslo, logická hodnota, objekt, pole, null)
• Formáty reťazcov (`format`: e-mail, uuid, dátum-čas a ďalšie)
• Zodpovedanie vzoru pre reťazce (`pattern`)
• Číselné rozsahy (`minimum`, `maximum`)
• Overenie dĺžky poľa a položiek (`minItems`, `maxItems`, `items`)
• Vnorená validácia pre objekty a polia
• Obmedzenia výčtového typu (`enum`)

Príklad: Používateľská schéma (Návrh-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
}

Čo toto vynucuje:

• ID musí byť platný reťazec UUID.
• názov musí byť neprázdny reťazec.
• email musí zodpovedať štandardnému formátu emailu.
• is_active (voliteľné) musí byť pravdivostná hodnota (boolean).
• S výnimkou vyššie uvedených nie sú povolené žiadne ďalšie vlastnosti.

Príklad z praxe: Overovanie odpovedí Stripe API

Predstavte si, že od API Stripe (napríklad PaymentIntent) prijímate odpovede vo formáte JSON. Validácia schémy zabezpečí, že nikdy nespracujete neúplné alebo nesprávne typované údaje.

{
  "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": [
      "vyžaduje_spôsob_platby",
      "vyžaduje_potvrdenie",
      "spracúva_sa",
      "úspešná",
      "zrušená"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• id musí začínať "pi_"
• objekt musí byť vždy "payment_intent"
• množstvo musí byť celé číslo väčšie alebo rovné 1
• mena musí byť trojpísmenový reťazec (napr. „usd“, „eur“)
• stav musí byť jednou zo zadaných hodnôt

Výhody

• Včasné odhalenie chýb: Zachyťte zásadné zmeny v API alebo neúplné dáta skôr, než ovplyvnia vašu podnikateľskú logiku.
• Automatizované testovanie: Využívajte schémy v CI/CD pipeline na validáciu reálnych a simulovaných odpovedí.
• Konzistencia naprieč tímami: Štandardizujte dátové zmluvy medzi frontend, backend a API tretích strán.

Správna validácia JSON — zahŕňajúca syntaktickú aj schémovú kontrolu — zabraňuje skrytým chybám, presadzuje osvedčené postupy a chráni vaše aplikácie pred nesprávnym alebo škodlivým vstupom. Či už sa používa v konfiguračných súboroch, API dátových paketoch alebo pri medzi-servisnej komunikácii, spoľahlivá validácia je základom moderných softvérových systémov.

Súkromie a bezpečnosť

Všetky overenia a kontroly schém prebiehajú lokálne vo vašom prehliadači. Žiadne údaje sa neodosielajú ani nezaznamenávajú. Váš JSON zostáva úplne súkromný.

Príklady kódu na validáciu JSON

Pozrite si, ako overiť JSON v rôznych programovacích jazykoch pomocou vstavaných knižníc alebo populárnych frameworkov. Tieto príklady ukazujú overovanie syntaxe aj overovanie podľa schémy.

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 tomto nástroji