Валидатор на JSON

Какво е валидиране на JSON?

JSON (JavaScript Object Notation) е широко използван, лек формат за обмен на данни, създаден да бъде както лесно разбираем за хората, така и лесен за обработка от компютърни системи. Неговата основна цел е да представлява структурирани данни — обекти, масиви, низове, числа, булеви стойности и null — по езиково независим начин.

Валидирането на JSON е процес на програмен контрол дали JSON документът е както синтактично, така и структурно правилен. Това включва проверка на два основни аспекта:

• Синтактично валидиране: Осигуряване на съответствието на суровия текст с официалната граматика, дефинирана от спецификацията ECMA-404 JSON. Парсърите в повечето съвременни програмни езици (например JSON.parse() в JavaScript, json.loads() в Python, JSONDecoder в Java) очакват валиден синтаксис и ще върнат грешки при неправилно форматиран вход.
• Структурна (Схема) Валидация: Освен синтаксиса, валидацията на схема проверява дали JSON данните съответстват на очаквана структура, включително типове данни, задължителни свойства, ограничения на стойностите и вложени обекти/масиви. Валидацията на схема обикновено се извършва с помощта на JSON Schema, която задава правила за това какви данни се считат за валидни.

Защо да валидираме JSON?

Валидирането на JSON е от съществено значение при сериализация на данни за предаване, съхранение или междусервизна комуникация. Основните причини включват:

• Предотвратяване на грешки: Откривайте и докладвайте синтактични грешки (например липсващи запетаи, несъответстващи скоби, незаконни символи) рано — преди опит да се обработват данни.
• Цялостност и сигурност на данните: Отхвърляне на неправилно формирани или злонамерени JSON съобщения, което помага за предотвратяване на сривове на сървъра, инжекционни атаки и разрушаване на данни.
• Типова сигурност: Прилагайте стриктно типизиране — гарантирайки например, че поле, което трябва да е булево, не се изпраща като низ, както и че UUID, имейли или числа следват правилния формат.
• Съвместимост между езици: Гарантирайте, че JSON, генериран в една среда (напр. Node.js), ще бъде безопасно използваем в друга (напр. Python, Go, Java), като се избягват грешки при сериализация/десериализация.
• Поддръжка и Здравина: Валидираните структури от данни подобряват проследимостта и намаляват риска от трудни за отстраняване грешки във файлове с конфигурации, логове или заявки/отговори на API.
• Поверителност и сигурност: Валидирането може да се извърши изцяло на страна на клиента (в браузъра), което предотвратява изпращането на сурови или чувствителни данни от устройството на потребителя за валидация.

Чести грешки при валидиране на JSON (с подробни примери)

Ключове без кавички

Всички ключове в JSON обектите трябва да бъдат стрингове с двойни кавички.

{ name: "Алис" }

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

Много формати, подобни на JSON (например обекти в JavaScript), позволяват ключове без кавички, но стандартният JSON изисква кавички.

Единични кавички

JSON низовете трябва да използват само двойни кавички; единични кавички не са разрешени.

{ 'name': 'Боб' }

{ "name": "Боб" }

Използването на единични кавички ще доведе до грешки при анализатора във всички съвместими JSON библиотеки.

Завършващи запетаи

Без запетая след последния елемент в обект или масив.

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

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

Завършващите запетаи могат да работят в JavaScript, но не и в строги JSON парсъри.

Неправилно избягване на символи

Кавичките и специалните символи в низовете трябва да бъдат екранирани с обратна наклонена черта.

{ "quote": "Том каза „здравей"" }

{ "quote": "Том каза \"здравей\"" }

Други управляващи последователности включват \\ за обратна наклонена черта, \n за нов ред и \t за табулации.

Неправилни типове данни

Низове не трябва да се използват за числа, булеви стойности или нулеви стойности.

{ "enabled": "вярно", "count": "10" }

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

JSON прави разлика между булеви стойности, числа и низове — уверете се, че използвате правилния тип.

Непървични ключове

Ключовете в JSON обекти винаги трябва да са низове; не можете да използвате числа, булеви стойности или други типове като ключове.

{ 123: "абв" }

{ "123": "abc" }

Дублиращи се ключове

Въпреки че JSON спецификацията ги позволява, дублиращите се ключове са честа причина за грешки.

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

Повечето парсъри ще запазят само последната стойност ("Боб"), безшумно изхвърляйки по-ранните.

Използване на коментари

Стандартният JSON не позволява коментари, въпреки че някои редактори ги поддържат.

{
  // Информация за потребителя
  "name": "Алис"
}

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

Валидация на схема: Налагане на структура и типове данни

JSON Schema е мощен стандарт за дефиниране и валидиране на очакваната структура на JSON документи. Той ви позволява да посочите:

• Задължителни полета (`required`)
• Типове данни (`type`: низ, число, булев, обект, масив, null)
• Формати на низове (`format`: имейл, UUID, дата-време и др.)
• Съответствие на модели за низове (`pattern`)
• Числови диапазони (`минимум`, `максимум`)
• Проверка на дължината на масив и елементи (`minItems`, `maxItems`, `items`)
• Вложена валидация за обекти и масиви
• Ограничения за избиране от списък (`enum`)

Пример: Схема на потребител (Проект-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
}

Какво това налага:

• id трябва да е валиден низ във формат UUID.
• името трябва да е непразен низ.
• имейлът трябва да съответства на стандартния формат за имейл.
• is_active (по избор) трябва да бъде булева стойност.
• Не се допускат други свойства освен посочените по-горе.

Пример от реалния свят: Валидиране на отговорите от Stripe API

Представете си, че получавате JSON отговори от Stripe API (например PaymentIntent). Валидирането на схемата гарантира, че никога няма да обработвате непълни или неправилно типизирани данни.

{
  "type": "обект",
  "properties": {
    "id":      { "type": "низ", "pattern": "^pi_" },
    "object":  { "type": "низ", "const": "payment_intent" },
    "amount":  { "type": "цяло число", "minimum": 1 },
    "currency":{ "type": "низ", "minLength": 3, "maxLength": 3 },
    "status":  { "type": "низ", "enum": [
      "изисква_метод_на_плащане",
      "изисква_потвърждение",
      "обработва_се",
      "успешно_завършено",
      "отказано"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• id трябва да започва с "pi_"
• обектът трябва винаги да бъде "payment_intent"
• количеството трябва да е цяло число, по-голямо или равно на 1
• валутата трябва да е низ от три букви (напр. "usd", "eur")
• състоянието трябва да е една от посочените стойности

Ползи

• Ранно откриване на грешки: Засичайте критични промени в API или непълни данни, преди да достигнат до вашата бизнес логика.
• Автоматизирано тестване: Използвайте схеми в CI/CD процеси за валидиране на реални и симулирани отговори.
• Последователност между екипите: Стандартизирайте договорите за данни между frontend, backend и външни API-та.

Правилната валидация на JSON — включително както на синтаксиса, така и на схемата — предотвратява скрити грешки, налага добри практики и защитава вашите приложения от неправилни или злонамерени входни данни. Независимо дали се използва в конфигурационни файлове, API съобщения или междусървърна комуникация, здравата валидация е основен компонент на съвременните софтуерни системи.

Поверителност и сигурност

Всички проверки за валидност и схема се изпълняват локално във вашия браузър. Никакви данни не се качват или записват. Вашият JSON остава напълно личен.

Примери с код за валидиране на JSON

Вижте как да валидирате 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)
  }
}

За този инструмент