Гарантирует ли 200 статус кода что все прошло успешно

HTTP 200 статус код: гарантирует ли он успех?

Короткий ответ: НЕТ. Статус код 200 не гарантирует успех операции. Это очень важная тема для обработки ошибок в приложениях.

Что означает 200 OK

200 OK — это просто означает, что:

1. Сервер получил запрос
2. Запрос синтаксически верен
3. Сервер смог обработать запрос и вернуть ответ

НО это НЕ гарантирует, что операция была успешной с точки зрения бизнес-логики!

Проблема 1: Ошибки в теле ответа

// Сервер возвращает 200, но с ошибкой в теле
const response = await fetch('/api/login', {
  method: 'POST',
  body: JSON.stringify({ email: 'john@example.com', password: 'wrong' })
});

console.log(response.status); // 200 OK

const data = await response.json();
console.log(data);
// {
//   "success": false,
//   "error": "Invalid password"
// }

// 200 статус, но login НЕ прошёл!

Проблема 2: Частичный успех

const response = await fetch('/api/bulk-delete', {
  method: 'DELETE',
  body: JSON.stringify({ ids: [1, 2, 3, 4, 5] })
});

const data = await response.json();
// {
//   "deleted": [1, 2, 3],
//   "failed": [4, 5],
//   "message": "Deleted 3 out of 5"
// }

// Статус 200, но не все элементы удалены!

Проблема 3: Медленные операции

const response = await fetch('/api/process-video', {
  method: 'POST',
  body: JSON.stringify({ videoId: 'abc123' })
});

// 200 OK
const data = await response.json();
// {
//   "status": "processing",
//   "jobId": "job_12345"
// }

// Операция ещё не завершена! Нужно проверить статус позже

Проблема 4: Пустой ответ

const response = await fetch('/api/search?q=nonexistent');
console.log(response.status); // 200

const data = await response.json();
console.log(data); // []

// Поиск не нашёл результаты, но статус 200
// Это успех? Зависит от контекста!

Правильная обработка ошибок

НЕПРАВИЛЬНО: проверять только статус

// ПЛОХО
async function updateUser(userId, data) {
  const response = await fetch(`/api/users/${userId}`, {
    method: 'PATCH',
    body: JSON.stringify(data)
  });
  
  if (response.ok) { // 200-299
    console.log('Успех!'); // Неправильно!
    return data;
  }
  
  throw new Error('Ошибка');
}

ПРАВИЛЬНО: проверять и тело ответа

// ХОРОШО
async function updateUser(userId, data) {
  const response = await fetch(`/api/users/${userId}`, {
    method: 'PATCH',
    body: JSON.stringify(data)
  });
  
  const result = await response.json();
  
  // Проверяем статус КОД
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${result.error}`);
  }
  
  // Проверяем статус в ТЕЛЕ
  if (!result.success) {
    throw new Error(result.error || 'Unknown error');
  }
  
  return result.data;
}

Таблица HTTP статус кодов

Реальные примеры ошибок с 200 статусом

Пример 1: API платёжной системы

const response = await fetch('https://payment-api.com/charge', {
  method: 'POST',
  body: JSON.stringify({ amount: 100, cardToken: 'tok_123' })
});

const result = await response.json();
// {
//   "status": 200,
//   "success": false,
//   "error": "Card declined",
//   "transactionId": null
// }

// Статус 200, но платёж НЕ прошёл!

Пример 2: Валидация данных

const response = await fetch('/api/register', {
  method: 'POST',
  body: JSON.stringify({
    email: 'invalid-email',
    password: '123'
  })
});

const result = await response.json();
// {
//   "status": 200,
//   "success": false,
//   "errors": {
//     "email": "Invalid email format",
//     "password": "Too short"
//   }
// }

// Регистрация НЕ прошла, но статус 200

Пример 3: Частичный успех

const response = await fetch('/api/send-notifications', {
  method: 'POST',
  body: JSON.stringify({ userIds: [1, 2, 3, 4, 5] })
});

const result = await response.json();
// {
//   "status": 200,
//   "sent": 3,
//   "failed": 2,
//   "errors": [
//     { userId: 4, reason: "Invalid email" },
//     { userId: 5, reason: "Blocked user" }
//   ]
// }

// Некоторые уведомления отправлены, некоторые нет

Правильный паттерн обработки

class APIError extends Error {
  constructor(status, message, details) {
    super(message);
    this.status = status;
    this.details = details;
  }
}

async function apiRequest(url, options) {
  const response = await fetch(url, options);
  const data = await response.json();
  
  // Проверка 1: HTTP статус
  if (!response.ok) {
    throw new APIError(
      response.status,
      `HTTP ${response.status}: ${data.message}`,
      data
    );
  }
  
  // Проверка 2: Поле "success" или "error" в ответе
  if (!data.success && data.error) {
    throw new APIError(
      response.status,
      data.error,
      data
    );
  }
  
  // Проверка 3: Наличие данных (если ожидаются)
  if (data.data === undefined && data.data === null) {
    throw new APIError(
      response.status,
      'No data in response',
      data
    );
  }
  
  return data.data || data;
}

// Использование
try {
  const user = await apiRequest('/api/user/1');
  console.log(user);
} catch (error) {
  if (error instanceof APIError) {
    console.error(`API Error: ${error.message}`);
  } else {
    console.error('Unknown error:', error);
  }
}

Рекомендуемая структура API ответа

Good API design:

{
  "success": true,
  "data": { ... },
  "message": "User updated successfully"
}

{
  "success": false,
  "error": "User not found",
  "code": "USER_NOT_FOUND"
}

Bad API design (смешивает статусы):

{
  "status": 200,
  "message": "Error: user not found"
}

React пример с обработкой

interface APIResponse<T> {
  success: boolean;
  data?: T;
  error?: string;
}

async function fetchUser(id: string): Promise<User> {
  const response = await fetch(`/api/users/${id}`);
  const result: APIResponse<User> = await response.json();
  
  // Всегда проверяй success флаг
  if (!result.success || !result.data) {
    throw new Error(result.error || 'Failed to fetch user');
  }
  
  return result.data;
}

function UserProfile() {
  const [user, setUser] = useState<User | null>(null);
  const [error, setError] = useState<string | null>(null);
  
  useEffect(() => {
    fetchUser('123')
      .then(setUser)
      .catch(err => setError(err.message));
  }, []);
  
  if (error) return <div>Error: {error}</div>;
  if (!user) return <div>Loading...</div>;
  
  return <div>{user.name}</div>;
}

Итоговые правила

1. НИКОГДА не полагайся только на статус код

// ПЛОХО
if (response.status === 200) {
  // Это НЕ гарантирует успех!
}

1. ВСЕГДА проверяй тело ответа

// ХОРОШО
const data = await response.json();
if (!data.success) {
  // Обработай ошибку из тела
}

1. Используй правильные HTTP коды на бэкенде

// В Node.js/Express
router.post('/login', (req, res) => {
  if (!isValid) {
    // Неверный логин/пароль — 401 Unauthorized
    return res.status(401).json({ error: 'Invalid credentials' });
  }
  
  // Успех — 200 OK с данными
  res.json({ success: true, token });
});

1. Добавляй явное поле success в ответе

2. Логируй полные ошибки для дебага

3. Используй типы (TypeScript) для обязательных проверок

Запомни: 200 статус код только означает, что HTTP запрос был успешен. Успех операции нужно проверять в теле ответа!