ஒரு response-க்கு சரியான HTTP status code-ஐ எப்படித் தேர்ந்தெடுப்பது?

Question

IT Interview Practice · Accepted Answer

HTTP status codes அவற்றின் முதல் இலக்கத்தால் **ஐந்து வகுப்புகளாக** தொகுக்கப்படுகின்றன, சரியானதைத் தேர்ந்தெடுப்பது body-ஐ parse செய்யாமல் clients சரியாக எதிர்வினையாற்ற அனுமதிக்கிறது.

```text
2xx  Success        — the request worked
3xx  Redirection    — further action / resource moved
4xx  Client error   — the caller did something wrong
5xx  Server error   — the server failed
```

## நீங்கள் உண்மையில் பயன்படுத்தும் codes

**2xx**
- `200 OK` — பொது வெற்றி (`GET`, `PUT`, `PATCH`).
- `201 Created` — ஒரு resource உருவாக்கப்பட்டது (ஒரு `Location` header-ஐத் திருப்பவும்).
- `202 Accepted` — **async** செயலாக்கத்திற்கு ஏற்கப்பட்டது, இன்னும் முடியவில்லை.
- `204 No Content` — body இல்லாத வெற்றி (`DELETE`-க்கு பொதுவானது).

**4xx**
- `400 Bad Request` — தவறான syntax அல்லது தவறான input.
- `401 Unauthorized` — authenticate செய்யப்படவில்லை (credentials இல்லை/தவறானது).
- `403 Forbidden` — authenticate செய்யப்பட்டது ஆனால் அனுமதிக்கப்படவில்லை.
- `404 Not Found` — resource இல்லை.
- `409 Conflict` — தற்போதைய நிலையுடன் முரண்படுகிறது (உ.ம். duplicate email).
- `422 Unprocessable Entity` — நன்கு-வடிவமைக்கப்பட்டது ஆனால் validation-இல் தோல்வி.
- `429 Too Many Requests` — rate limited.

**5xx**
- `500 Internal Server Error` — எதிர்பாராத server fault.
- `503 Service Unavailable` — தற்காலிகமாக down/overloaded.

## எடுத்துக்காட்டுகள்

```http
POST /users  →  201 Created
Location: /users/42

DELETE /users/42  →  204 No Content

GET /users/999  →  404 Not Found
{ "error": "user not found" }
```

Interviewers ஆராயும் முக்கிய வேறுபாடு: `401` ("நீ யார்?") vs `403` ("உன்னை எனக்குத் தெரியும், ஆனால் இல்லை"), மற்றும் `400` (தவறான syntax) vs `422` (சரியான syntax, தவறான data).

## இது ஏன் முக்கியம்

Status codes ஒரு REST response-இல் முதன்மை சமிக்ஞை — clients, proxies, monitoring, மற்றும் retry logic அனைத்தும் அவற்றை அடிப்படையாகக் கொள்கின்றன, எனவே அவற்றைச் சரியாகப் பெறுவது interoperability-க்கு அத்தியாவசியம். ஒரு பொதுவான தோல்வி `200 OK`-ஐ ஒரு `{ "error": ... }` body-உடன் திருப்புவது: அது ஒவ்வொரு client-ஐயும் call வெற்றி பெற்றதா என்று அறிய body-ஐ parse செய்யக் கட்டாயப்படுத்துகிறது, generic HTTP tooling-ஐ உடைக்கிறது, மற்றும் monitoring-இலிருந்து தோல்விகளை மறைக்கிறது. துல்லியமான codes தானியங்கி நடத்தையையும் இயக்குகின்றன: ஒரு `429` அல்லது `503` நன்கு-கட்டப்பட்ட client-ஐ back off செய்து retry செய்யச் சொல்கிறது, அதேசமயம் ஒரு `4xx` "retry செய்யாதே, request-ஐ சரிசெய்" என்று சொல்கிறது. HTTP-ஐ ஒரு மந்தமான transport-க்குப் பதிலாக ஒரு contract-ஆக நீங்கள் புரிந்துகொள்கிறீர்களா, மற்றும் நுட்பமான ஜோடிகளை (`401`/`403`, `400`/`422`) சரியாக வேறுபடுத்துகிறீர்களா என்று சரிபார்க்க interviewers இதைப் பயன்படுத்துகிறார்கள் — உண்மையான APIs-ஐக் கட்டியும் பயன்படுத்தியும் இருப்பவரின் அடையாளம் இது.

நீங்கள் உண்மையில் பயன்படுத்தும் codes

எடுத்துக்காட்டுகள்

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்