Работа с JSON

JSON (JavaScript Object Notation) - это текстовый формат обмена данными, основанный на JavaScript, но независимый от языка. Сегодня это стандарт де-факто для HTTP API.

Что такое JSON?

JSON - это способ представления структурированных данных в виде текста. Он легко читается человеком и легко парсится машиной.

Пример JSON:

{
  "name": "John Doe",
  "age": 30,
  "email": "john@example.com",
  "isActive": true,
  "roles": ["admin", "user"],
  "address": {
    "street": "123 Main St",
    "city": "New York",
    "country": "USA"
  }
}

Типы данных в JSON

JSON по стандарту RFC 8259 поддерживает 6 типов данных:

1. Строки (string)

{
  "name": "Alice",
  "message": "Hello, World!",
  "unicode": "Привет! 👋"
}

Строки всегда в двойных кавычках. Специальные символы экранируются:

  • \" - кавычка
  • \\ - обратный слэш
  • \n - новая строка
  • \t - табуляция
  • \u0041 - Unicode символ

2. Числа (number)

{
  "integer": 42,
  "float": 3.14159,
  "negative": -273.15,
  "scientific": 1.23e-4
}

3. Булевы значения (boolean)

{
  "isActive": true,
  "isDeleted": false
}

4. null

{
  "middleName": null,
  "deletedAt": null
}

5. Объекты (object)

{
  "user": {
    "id": 1,
    "profile": {
      "firstName": "John",
      "lastName": "Doe"
    }
  }
}

6. Массивы (array)

{
  "numbers": [1, 2, 3, 4, 5],
  "mixed": [1, "two", true, null],
  "users": [
    {"id": 1, "name": "Alice"},
    {"id": 2, "name": "Bob"}
  ]
}

Что НЕ поддерживает JSON

  • Комментарии
  • Функции
  • undefined
  • Даты (передаются как строки)
  • Trailing comma
// Это НЕ валидный JSON:
{
  "name": "John",  // комментарий не поддерживается
  "birthday": new Date(),  // функции/объекты не поддерживаются
  "callback": function() {},  // функции не поддерживаются, а запятая после последнего поля (trailing comma) запрещена
}

Даты передают строкой, обычно в формате ISO 8601: "2026-11-11T10:30:00Z" (дата, T, время, Z - часовой пояс UTC). Такую строку однозначно разбирают все языки, а сортировка строк совпадает с сортировкой по времени.

Работа с JSON в разных языках

В браузере (JavaScript) для этого есть встроенный объект JSON: JSON.stringify(obj) превращает объект в JSON-строку, JSON.parse(str) - обратно, а на невалидной строке JSON.parse выбрасывает SyntaxError. На бэкенде то же самое делают так:

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    Name  string `json:"name"`
    Age   int    `json:"age"`
    Email string `json:"email,omitempty"`
}

func main() {
    // Парсинг JSON
    jsonStr := `{"name": "Alice", "age": 30}`
    var user User
    err := json.Unmarshal([]byte(jsonStr), &user)
    if err != nil {
        panic(err)
    }
    fmt.Println(user.Name) // Alice

    // Преобразование в JSON
    newUser := User{Name: "Bob", Age: 25}
    jsonBytes, _ := json.Marshal(newUser)
    fmt.Println(string(jsonBytes))

    // Красивый вывод
    prettyJSON, _ := json.MarshalIndent(newUser, "", "  ")
    fmt.Println(string(prettyJSON))
}
<?php
// Парсинг JSON
$json = '{"name": "Alice", "age": 30}';
$data = json_decode($json);
echo $data->name; // Alice

// Как ассоциативный массив
$array = json_decode($json, true);
echo $array['name']; // Alice

// Преобразование в JSON
$user = [
    'name' => 'Bob',
    'age' => 25
];
$json = json_encode($user);

// Красивый вывод
$prettyJson = json_encode($user, JSON_PRETTY_PRINT);

// Обработка ошибок
$data = json_decode($invalidJson);
if (json_last_error() !== JSON_ERROR_NONE) {
    echo 'Ошибка: ' . json_last_error_msg();
}
?>
import json
from dataclasses import asdict, dataclass


@dataclass
class User:
    name: str
    age: int
    email: str | None = None


# Парсинг JSON
json_str = '{"name": "Alice", "age": 30}'
data = json.loads(json_str)
print(data["name"])  # Alice

# В dataclass: ключи JSON становятся аргументами конструктора
user = User(**data)
print(user.name)  # Alice

# Преобразование в JSON
new_user = User(name="Bob", age=25)
fields = {k: v for k, v in asdict(new_user).items() if v is not None}  # аналог omitempty
json_bytes = json.dumps(fields)
print(json_bytes)  # {"name": "Bob", "age": 25}

# Красивый вывод
pretty_json = json.dumps(fields, indent=2)
print(pretty_json)

# Обработка ошибок
try:
    json.loads("{invalid}")
except json.JSONDecodeError as e:
    print(f"Ошибка: {e.msg}")

Валидация JSON

Онлайн-инструменты:

Программная валидация:

import "encoding/json"

// isValidJSON проверяет синтаксис, не разбирая документ в структуру.
func isValidJSON(s string) bool {
    return json.Valid([]byte(s))
}
<?php
declare(strict_types=1);

// С PHP 8.3 есть json_validate($str): проверяет синтаксис без построения
// массива и экономит память. Вариант ниже работает и на версиях до 8.3.
function isValidJson(string $str): bool
{
    try {
        json_decode($str, flags: JSON_THROW_ON_ERROR);
        return true;
    } catch (JsonException) {
        return false;
    }
}
import json


def _reject_constant(name: str) -> None:
    # NaN/Infinity не входят в стандарт JSON, а json.loads их по умолчанию принимает
    raise ValueError(f"invalid JSON constant: {name}")


def is_valid_json(s: str) -> bool:
    """Пробует разобрать строку как JSON."""
    try:
        json.loads(s, parse_constant=_reject_constant)
        return True
    except ValueError:  # JSONDecodeError - тоже ValueError
        return False
    except RecursionError:  # слишком глубокая вложенность, например "[" * 5000
        return False

JSON Schema

JSON Schema позволяет описать структуру и валидировать JSON:

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1
    },
    "age": {
      "type": "integer",
      "minimum": 0,
      "maximum": 150
    },
    "email": {
      "type": "string",
      "format": "email"
    }
  },
  "required": ["name", "email"]
}

Лучшие практики

1. Используйте осмысленные имена

// Плохо
{
  "n": "John",
  "a": 30,
  "e": "john@example.com"
}

// Хорошо
{
  "name": "John",
  "age": 30,
  "email": "john@example.com"
}

2. Будьте консистентны в именовании

// camelCase
{
  "firstName": "John",
  "lastName": "Doe",
  "emailAddress": "john@example.com"
}

// snake_case
{
  "first_name": "John",
  "last_name": "Doe",
  "email_address": "john@example.com"
}

3. Используйте массивы для списков

// Плохо
{
  "user1": {"name": "Alice"},
  "user2": {"name": "Bob"},
  "user3": {"name": "Charlie"}
}

// Хорошо
{
  "users": [
    {"name": "Alice"},
    {"name": "Bob"},
    {"name": "Charlie"}
  ]
}

4. Избегайте глубокой вложенности

// Слишком глубоко
{
  "data": {
    "users": {
      "list": {
        "items": [...]
      }
    }
  }
}

// Лучше
{
  "users": [...]
}

Альтернативы JSON

  • XML - более многословный, но поддерживает атрибуты и namespaces
  • YAML - более читаемый, поддерживает комментарии
  • MessagePack - бинарный формат, компактнее JSON
  • Protocol Buffers - бинарный формат от Google, требует схемы

Производительность

При работе с большими объёмами данных:

  1. Streaming парсинг - обрабатывайте JSON по частям
  2. Бинарные форматы - используйте MessagePack или Protobuf
  3. Сжатие - используйте gzip для передачи по сети
  4. Кеширование - храните распарсенные объекты

Итоги

JSON - это простой, но мощный формат для обмена данными. Его поддерживают все современные языки и платформы. Понимание JSON критически важно для:

  • Разработки и использования API
  • Конфигурационных файлов
  • Обмена данными между системами
  • Хранения структурированных данных

В следующем уроке мы рассмотрим, как защитить API с помощью различных методов аутентификации и авторизации. Парсинг JSON на стороне браузера - через fetch, на сервере Go - через encoding/json.

Зарегистрируйтесь бесплатно, чтобы пройти квиз, вести прогресс.