Валидатор 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": "Том сказал \"привет\"" }

Другие escape-последовательности включают \\ для обратной косой черты, \n для новых строк и \t для табуляции.

Неверные типы данных

Строки не должны использоваться для чисел, булевых значений или null.

{ "enabled": "включено", "count": "10" }

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

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

Непримитивные ключи

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

{ 123: "abc" }

{ "123": "абв" }

Дубликаты ключей

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

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

Большинство парсеров сохраняет только последнее значение («Боб»), тихо игнорируя предыдущие.

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

Стандартный JSON не поддерживает комментарии, хотя некоторые редакторы их и допускают.

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

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

Проверка схемы: обеспечение структуры и типов данных

JSON Schema — это мощный стандарт для определения и проверки ожидаемой структуры JSON-документов. Он позволяет задавать:

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

Пример: Схема пользователя (Draft-07)

{
  "type": "объект",
  "properties": {
    "id":    { "type": "строка", "format": "uuid" },
    "name":  { "type": "строка", "minLength": 1 },
    "email": { "type": "строка", "format": "email" },
    "is_active": { "type": "логическое" }
  },
  "required": ["id", "name", "email"],
  "additionalProperties": false
}

Что это обеспечивает:

• id должен быть корректной строкой UUID.
• имя должно быть непустой строкой.
• электронная почта должна соответствовать стандартному формату адреса.
• is_active (необязательно) должно быть логическим значением.
• Разрешены только свойства, указанные выше.

Практический пример: проверка ответов API Stripe

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

{
  "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": [
      "требуется_способ_оплаты",
      "требуется_подтверждение",
      "в_обработке",
      "успешно",
      "отменено"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• id должен начинаться с "pi_"
• объект всегда должен быть "payment_intent"
• сумма должна быть целым числом, не меньше 1
• валюта должна быть строкой из трёх букв (например, "usd", "eur")
• статус должен быть одним из указанных значений

Преимущества

• Раннее обнаружение ошибок: выявляйте критические изменения в API или неполные данные до их попадания в вашу бизнес-логику.
• Автоматизированное тестирование: используйте схемы в CI/CD-пайплайнах для проверки реальных и имитированных ответов.
• Единообразие между командами: стандартизация контрактов данных между фронтендом, бэкендом и API сторонних сервисов.

Корректная проверка JSON — включая как синтаксис, так и схему — предотвращает скрытые ошибки, обеспечивает соблюдение лучших практик и защищает ваши приложения от неправильных или вредоносных данных. Независимо от того, используется ли 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)
  }
}

О данном инструменте