HTTP методы GET, POST, PUT, DELETE: полное руководство с примерами

Введение

HTTP методы — это фундамент, на котором построен весь веб. Каждый раз, когда вы открываете страницу, отправляете форму, загружаете файл или удаляете аккаунт — за кулисами работает конкретный HTTP метод, который говорит серверу, что именно вы хотите сделать.

В REST API правильное использование HTTP методов — не просто конвенция, а ключевой принцип проектирования. Неправильный выбор метода ломает кэширование, нарушает безопасность и превращает API в непредсказуемый хаос.

В этой статье вы узнаете:

• ✅ Все основные HTTP методы и их назначение
• ✅ Разницу между GET и POST, PUT и PATCH
• ✅ Что такое идемпотентность и безопасность методов
• ✅ Примеры кода на JavaScript, Python и PHP
• ✅ Типичные ошибки и как их избежать

Что такое HTTP методы

HTTP метод (HTTP verb) — это указание серверу, какое действие нужно выполнить с запрашиваемым ресурсом. Метод передаётся в первой строке HTTP-запроса:

GET /api/users HTTP/1.1
Host: example.com
Accept: application/json

Здесь GET — метод, /api/users — ресурс, к которому обращаемся.

Обзор всех HTTP методов

Стандарт HTTP определяет 9 методов, но в повседневной разработке API используются 5–7 из них:

GET — получение данных

GET — самый распространённый HTTP метод. Используется для получения данных с сервера без их изменения.

Характеристики GET

• Безопасный — не изменяет данные на сервере
• Идемпотентный — повторный вызов даёт тот же результат
• Кэшируемый — браузер и прокси могут кэшировать ответ
• Без тела запроса — параметры передаются в URL (query string)

Примеры запросов

// Получить список пользователей
fetch('/api/users')
  .then(res => res.json())
  .then(users => console.log(users));
// GET /api/users → 200 OK

// Получить одного пользователя по ID
fetch('/api/users/42')
  .then(res => res.json())
  .then(user => console.log(user));
// GET /api/users/42 → 200 OK

// Фильтрация и пагинация через query string
fetch('/api/users?role=admin&page=2&limit=10')
  .then(res => res.json())
  .then(data => console.log(data));
// GET /api/users?role=admin&page=2&limit=10 → 200 OK

Типичные ответы

POST — создание ресурса

POST используется для создания нового ресурса на сервере. Данные передаются в теле запроса.

Характеристики POST

• Небезопасный — изменяет данные на сервере
• Не идемпотентный — повторный вызов создаёт ещё один ресурс
• Не кэшируемый — браузер не кэширует POST-запросы
• С телом запроса — данные передаются в body (JSON, form-data)

Примеры запросов

// Создать нового пользователя
const response = await fetch('/api/users', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: 'Иван Петров',
    email: 'ivan@example.com',
    role: 'developer'
  })
});

if (response.status === 201) {
  const newUser = await response.json();
  console.log('Создан:', newUser);
  // Заголовок Location: /api/users/43
  console.log('URL:', response.headers.get('Location'));
}

// Загрузить файл
const formData = new FormData();
formData.append('avatar', fileInput.files[0]);

await fetch('/api/users/42/avatar', {
  method: 'POST',
  body: formData
});

Типичные ответы

fetch('/api/payments', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Idempotency-Key': 'unique-request-id-12345'
  },
  body: JSON.stringify({ amount: 1000 })
});

PUT — полная замена ресурса

PUT заменяет ресурс целиком. Вы должны передать все поля объекта, даже те, которые не изменились.

Характеристики PUT

• Идемпотентный — повторный вызов с теми же данными даёт тот же результат
• Требует полного представления — все поля объекта
• Создаёт или заменяет — если ресурс не существует, PUT может его создать

Примеры запросов

// Полностью заменить данные пользователя
const response = await fetch('/api/users/42', {
  method: 'PUT',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: 'Иван Сидоров',       // изменили
    email: 'ivan.new@example.com', // изменили
    role: 'developer',            // не изменился, но НУЖНО передать
    age: 30                       // не изменился, но НУЖНО передать
  })
});

// 200 OK — ресурс обновлён
// 201 Created — ресурс не существовал и был создан

PATCH — частичное обновление

PATCH обновляет только указанные поля ресурса. Передаёте только то, что хотите изменить.

Характеристики PATCH

• Частичное обновление — только изменённые поля
• Не идемпотентный (формально) — хотя на практике часто ведёт себя идемпотентно
• Экономит трафик — не нужно передавать весь объект

Примеры запросов

// Обновить только email пользователя
const response = await fetch('/api/users/42', {
  method: 'PATCH',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    email: 'new.email@example.com'
    // Остальные поля НЕ передаём — они не изменятся
  })
});

// 200 OK — ресурс обновлён, возвращается полный объект

PUT vs PATCH — разница на примере

Допустим, у нас есть пользователь:

{
  "id": 42,
  "name": "Иван",
  "email": "ivan@example.com",
  "age": 30
}

Хотим изменить только email:

// Передаём ТОЛЬКО изменённое поле
PATCH /api/users/42
{ "email": "new@example.com" }

// Результат: age и name сохранены
{
  "id": 42,
  "name": "Иван",
  "email": "new@example.com",
  "age": 30
}

// Должны передать ВСЕ поля
PUT /api/users/42
{
  "name": "Иван",
  "email": "new@example.com",
  "age": 30
}

// Если забудем age:
PUT /api/users/42
{ "email": "new@example.com" }
// age станет null!

DELETE — удаление ресурса

DELETE удаляет ресурс на сервере.

Характеристики DELETE

• Идемпотентный — повторное удаление не создаёт ошибку (или возвращает 404)
• Обычно без тела запроса — ресурс идентифицируется по URL
• Может быть soft или hard delete — пометить как удалённый или удалить физически

Примеры запросов

// Удалить пользователя
const response = await fetch('/api/users/42', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer eyJhbGciOi...'
  }
});

if (response.status === 204) {
  console.log('Пользователь удалён');
}

if (response.status === 404) {
  console.log('Пользователь не найден');
}

Типичные ответы

HEAD и OPTIONS

HEAD — получить только заголовки

HEAD идентичен GET, но сервер возвращает только заголовки без тела ответа. Полезен для:

• Проверки существования ресурса без загрузки данных
• Определения размера файла перед скачиванием (Content-Length)
• Проверки актуальности кэша (Last-Modified, ETag)

// Проверить размер файла перед скачиванием
const response = await fetch('/api/files/report.pdf', {
  method: 'HEAD'
});

const fileSize = response.headers.get('Content-Length');
console.log(`Размер файла: ${(fileSize / 1024 / 1024).toFixed(2)} МБ`);

// Проверить, существует ли ресурс
const exists = response.status === 200;

OPTIONS — узнать доступные методы

OPTIONS возвращает информацию о доступных методах для данного URL. Активно используется в CORS preflight-запросах — браузер автоматически отправляет OPTIONS перед кросс-доменными запросами.

OPTIONS /api/users HTTP/1.1
Host: api.example.com

HTTP/1.1 204 No Content
Allow: GET, POST, OPTIONS
Access-Control-Allow-Methods: GET, POST, PUT, DELETE
Access-Control-Allow-Headers: Content-Type, Authorization
Access-Control-Max-Age: 86400

Идемпотентность и безопасность

Два ключевых свойства HTTP методов, которые влияют на архитектуру API, кэширование и обработку ошибок.

Безопасные методы (Safe)

Безопасный метод не изменяет состояние сервера. Его можно вызывать сколько угодно раз без побочных эффектов.

Идемпотентные методы (Idempotent)

Идемпотентный метод при повторном вызове с теми же данными даёт тот же результат. Состояние сервера после N вызовов то же, что и после одного.

CRUD-операции и HTTP методы

CRUD (Create, Read, Update, Delete) — четыре базовых операции с данными. Каждая операция соответствует HTTP методу:

Полные примеры на трёх языках

JavaScript (fetch API)

const API_BASE = 'https://api.example.com';

// GET — получить список
async function getUsers() {
  const res = await fetch(`${API_BASE}/users`);
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.json();
}

// POST — создать
async function createUser(userData) {
  const res = await fetch(`${API_BASE}/users`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(userData)
  });
  if (res.status !== 201) throw new Error(`HTTP ${res.status}`);
  return res.json();
}

// PUT — заменить целиком
async function replaceUser(id, userData) {
  const res = await fetch(`${API_BASE}/users/${id}`, {
    method: 'PUT',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(userData)
  });
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.json();
}

// PATCH — обновить частично
async function updateUser(id, fields) {
  const res = await fetch(`${API_BASE}/users/${id}`, {
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(fields)
  });
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.json();
}

// DELETE — удалить
async function deleteUser(id) {
  const res = await fetch(`${API_BASE}/users/${id}`, {
    method: 'DELETE'
  });
  if (res.status !== 204) throw new Error(`HTTP ${res.status}`);
  return true;
}

// Использование
const users = await getUsers();
const newUser = await createUser({ name: 'Иван', email: 'ivan@test.ru' });
await updateUser(newUser.id, { email: 'new@test.ru' });
await deleteUser(newUser.id);

Python (requests)

import requests

API_BASE = 'https://api.example.com'
headers = {'Content-Type': 'application/json'}

# GET — получить список
response = requests.get(f'{API_BASE}/users')
users = response.json()

# POST — создать
response = requests.post(f'{API_BASE}/users', json={
    'name': 'Иван',
    'email': 'ivan@test.ru'
}, headers=headers)

if response.status_code == 201:
    new_user = response.json()
    print(f'Создан: {new_user["id"]}')

# PUT — заменить целиком
response = requests.put(f'{API_BASE}/users/42', json={
    'name': 'Иван Сидоров',
    'email': 'ivan@test.ru',
    'role': 'admin'
}, headers=headers)

# PATCH — обновить частично
response = requests.patch(f'{API_BASE}/users/42', json={
    'email': 'new@test.ru'
}, headers=headers)

# DELETE — удалить
response = requests.delete(f'{API_BASE}/users/42')
if response.status_code == 204:
    print('Удалено')

PHP (cURL)

<?php

$apiBase = 'https://api.example.com';

function apiRequest(string $url, string $method = 'GET', ?array $data = null): array
{
    $ch = curl_init($url);
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CUSTOMREQUEST  => $method,
    ]);

    if ($data !== null) {
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'Content-Type: application/json'
        ]);
    }

    $response   = curl_exec($ch);
    $statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    return [
        'status' => $statusCode,
        'data'   => json_decode($response, true),
    ];
}

// GET — список
$result = apiRequest("$apiBase/users");
$users = $result['data'];

// POST — создать
$result = apiRequest("$apiBase/users", 'POST', [
    'name'  => 'Иван',
    'email' => 'ivan@test.ru',
]);
// $result['status'] === 201

// PUT — заменить
$result = apiRequest("$apiBase/users/42", 'PUT', [
    'name'  => 'Иван Сидоров',
    'email' => 'ivan@test.ru',
    'role'  => 'admin',
]);

// PATCH — обновить
$result = apiRequest("$apiBase/users/42", 'PATCH', [
    'email' => 'new@test.ru',
]);

// DELETE — удалить
$result = apiRequest("$apiBase/users/42", 'DELETE');
// $result['status'] === 204

Частые ошибки

GET /api/users/42/delete    ← НИКОГДА так не делайте
GET /api/users/42/activate  ← тоже плохо
GET /api/send-email?to=...  ← и так нельзя

POST /api → { "action": "getUser", "id": 42 }     ← RPC, не REST
POST /api → { "action": "deleteUser", "id": 42 }  ← антипаттерн

FAQ

PUT  /users/42 → { name, email, age } — ВСЕ поля обязательны
PATCH /users/42 → { email }           — только изменённое поле

POST /api/users         → Создай пользователя (ID назначит сервер)
PUT  /api/users/42      → Создай/замени пользователя #42 (ID знает клиент)

Заключение

Правильное использование HTTP методов — это не педантизм, а фундамент надёжного API. Когда каждый метод используется по назначению, API становится предсказуемым, кэшируемым, безопасным и удобным для клиентов.

Статья опубликована: 23 февраля 2026
Автор: LightBox API Team