Validátor JSON

Co je ověřování JSON?

JSON (JavaScript Object Notation) je široce používaný, lehký formát pro výměnu dat, navržený tak, aby byl čitelný pro lidi a zároveň snadno zpracovatelný stroji. Jeho hlavním účelem je reprezentovat strukturovaná data — objekty, pole, řetězce, čísla, hodnoty typu boolean a null — nezávisle na programovacím jazyce.

Validace JSON je proces programatického ověřování, že JSON dokument je jak syntakticky, tak strukturálně správný. Tento proces zahrnuje kontrolu dvou hlavních aspektů:

• Syntaxická validace: Zajištění, že surový text odpovídá formální gramatice definované specifikací ECMA-404 JSON. Parsovací nástroje v většině moderních programovacích jazyků (například JSON.parse() v JavaScriptu, json.loads() v Pythonu, JSONDecoder v Javě) očekávají platnou syntaxi a v případě chybného vstupu vyvolají chyby.
• Strukturální (schématická) validace: Kromě syntaxe kontrola správnosti schématu ověřuje, zda data JSON odpovídají očekávané struktuře, včetně datových typů, povinných vlastností, omezení hodnot a vnořených objektů/polí. Validace schématu se obvykle provádí pomocí JSON Schema, které definuje pravidla pro to, co je považováno za platná data.

Proč ověřovat JSON?

Validace JSON je nezbytná vždy, když jsou data serializována pro přenos, uložení nebo komunikaci mezi službami. Hlavní důvody zahrnují:

• Prevence chyb: Včasně detekujte a hlaste syntaktické chyby (např. chybějící čárky, nesoulad závorek, nepovolené znaky) ještě před zpracováním dat.
• Integrita a bezpečnost dat: Zamítnutí nesprávně formátovaných či škodlivých JSON dat, což pomáhá předcházet pádům backendu, injekčním útokům a poškození dat.
• Typová bezpečnost: Prosazujte přísné typování—zajistěte například, že pole očekávané jako boolean nebude odesláno jako řetězec, nebo že UUID, e-maily či čísla budou dodržovat správný formát.
• Kompatibilita mezi jazyky: Zajistěte, že JSON vytvořený v jednom prostředí (např. Node.js) bude bezpečně použitelný v jiném (např. Python, Go, Java), čímž se vyhnete chybám při serializaci a deserializaci.
• Udržovatelnost a Robustnost: Validované datové struktury zlepšují sledovatelnost a snižují riziko těžko odhalitelných chyb v konfiguračních souborech, záznamech či API požadavcích/odpovědích.
• Ochrana soukromí a bezpečnost: Validace může být provedena kompletně na straně klienta (v prohlížeči), což zabraňuje opuštění surových nebo citlivých dat z zařízení uživatele během ověřování.

Běžné chyby při validaci JSON (s podrobnými příklady)

Neuvedené klíče

Všechny klíče v objektech JSON musí být řetězce uzavřené v dvojitých uvozovkách.

{ name: "Alice" }

{ "name": "Alice" }

Mnoho formátů podobných JSON (například literály objektů v JavaScriptu) umožňuje nepoužívání uvozovek kolem klíčů, ale standardní JSON to neumožňuje.

Jednoduché uvozovky

Řetězce v JSON musí používat pouze dvojité uvozovky; jednoduché uvozovky nejsou povoleny.

{ 'name': 'Bob' }

{ "name": "Bob" }

Používání jednoduchých uvozovek způsobí chyby analyzátoru ve všech kompatibilních knihovnách JSON.

Uvozovací čárky

Za poslední položkou v objektu nebo poli nesmí být čárka.

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

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

Za poslední čárkou může JavaScript akceptovat, ale ve striktních JSON parserech není povolena.

Nesprávné escapování znaků

Uvnitř řetězců musí být uvozovky a speciální znaky escapovány pomocí zpětného lomítka.

{ "quote": "Tom řekl \"ahoj\"" }

{ "quote": "Tom řekl \"ahoj\"" }

Mezi další únikové sekvence patří \\ pro zpětné lomítko, \n pro nové řádky a \t pro tabulátory.

Nesprávné datové typy

Řetězce by neměly být používány pro čísla, booleovské hodnoty ani null.

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

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

JSON rozlišuje mezi booleovskými hodnotami, čísly a řetězci – zajistěte použití správného typu.

Nepůvodní klíče

Klíče v JSON objektu musí vždy být řetězce; nelze používat čísla, logické hodnoty ani jiné typy jako klíče.

{ 123: "abc" }

{ "123": "abc" }

Duplicitní klíče

I když je to povoleno specifikací JSON, duplicitní klíče jsou běžným zdrojem chyb.

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

Většina parserů si ponechá pouze poslední hodnotu („Bob“) a předchozí tiše ignoruje.

Používání komentářů

Standardní JSON nepodporuje komentáře, i když je některé editory umožňují.

{
  // Uživatelské informace
  "name": "Alice"
}

{
  "name": "Alice"
}

Validace schématu: prosazování struktury a typů dat

JSON Schema je silný standard pro definování a ověřování očekávané struktury JSON dokumentů. Umožňuje vám specifikovat:

• Povinná pole (`required`)
• Datové typy (`type`: řetězec, číslo, boolean, objekt, pole, null)
• Formáty řetězců (`format`: email, uuid, datum a čas, atd.)
• Porovnávání vzorů pro řetězce (`pattern`)
• Číselné rozsahy (`minimum`, `maximum`)
• Délka pole a kontrola položek (`minItems`, `maxItems`, `items`)
• Vnořená validace pro objekty a pole
• Enum omezení (`enum`)

Příklad: Uživatelský 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
}

Co toto vynucuje:

• id musí být platný řetězec UUID.
• jméno musí být neprázdný řetězec.
• email musí odpovídat standardnímu formátu e-mailu.
• is_active (volitelné) musí být logická hodnota.
• Nepovolují se žádné vlastnosti kromě těch výše uvedených.

Praktický příklad: Ověřování odpovědí Stripe API v reálném světě

Předpokládejme, že od API Stripe přijímáte odpovědi ve formátu JSON (například PaymentIntent). Validace schématu zajistí, že nikdy nebudete zpracovávat neúplná nebo nesprávně typovaná data.

{
  "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_způsob_placení",
      "vyžaduje_potvrzení",
      "zpracovává_se",
      "úspěšný",
      "zrušený"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• id musí začínat "pi_"
• objekt musí být vždy "payment_intent"
• částka musí být celé číslo větší nebo rovno 1
• měna musí být trojmístný řetězec (např. "usd", "eur")
• status musí být jednou z uvedených hodnot

Výhody

• Včasné odhalení chyb: Zachyťte zásadní změny API nebo neúplná data dříve, než ovlivní vaši obchodní logiku.
• Automatizované testování: Používejte schémata v CI/CD pipelinech pro ověřování skutečných i simulovaných odpovědí.
• Konzistence mezi týmy: Standardizujte datové smlouvy mezi frontendem, backendem a API třetích stran.

Správná validace JSON — zahrnující jak syntaxi, tak schéma — zabraňuje skrytým chybám, prosazuje osvědčené postupy a chrání vaše aplikace před špatně formátovanými či škodlivými vstupy. Ať už se používá v konfiguračních souborech, API datech nebo mezislužbové komunikaci, robustní validace je základem moderních softwarových systémů.

Soukromí a bezpečnost

Veškerá validace a kontrola schémat probíhá lokálně ve vašem prohlížeči. Žádná data nejsou nahrávána ani zaznamenávána. Váš JSON zůstává naprosto soukromý.

Ukázky kódu pro validaci JSON

Podívejte se, jak ověřovat JSON v různých programovacích jazycích pomocí vestavěných knihoven nebo populárních frameworků. Tyto příklady ukazují jak syntaktickou validaci, tak validaci podle schématu.

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