Работа с 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, требует схемы
Производительность
При работе с большими объёмами данных:
- Streaming парсинг - обрабатывайте JSON по частям
- Бинарные форматы - используйте MessagePack или Protobuf
- Сжатие - используйте gzip для передачи по сети
- Кеширование - храните распарсенные объекты
Итоги
JSON - это простой, но мощный формат для обмена данными. Его поддерживают все современные языки и платформы. Понимание JSON критически важно для:
- Разработки и использования API
- Конфигурационных файлов
- Обмена данными между системами
- Хранения структурированных данных
В следующем уроке мы рассмотрим, как защитить API с помощью различных методов аутентификации и авторизации. Парсинг JSON на стороне браузера - через fetch, на сервере Go - через encoding/json.