நீங்கள் routes (path operations) ஐ எவ்வாறு வரையறுக்கிறீர்கள்?

Question

IT Interview Practice · Accepted Answer

FastAPI-ல், ஒரு **path operation** என்பது route — ஒரு HTTP method decorator (`@app.get`, `@app.post`, முதலியவை) ஆல் அலங்கৃதமான ஒரு செயல்பாடு, இது பாதைக்கான கோரிக்கைகளைக் கையாளுகிறது. செயல்பாட்டின் திரும்பிய மதிப்பு தானாக JSON க்கு தொடரிணக்கம் செய்யப்படுகிறது.

## ஒவ்வொரு HTTP முறைக்கும் routes ஐ வரையறுத்தல்

```python
from fastapi import FastAPI
app = FastAPI()

@app.get("/items")                # GET /items
def list_items():
    return [{"id": 1}, {"id": 2}]  # dict/list → automatically JSON-serialized

@app.get("/items/{item_id}")      # GET /items/5 — path parameter
def get_item(item_id: int):        # type hint converts "5" → int (and validates)
    return {"id": item_id}

@app.post("/items")               # POST /items
def create_item(item: Item):
    return item

@app.put("/items/{item_id}")      # PUT, PATCH, DELETE work the same way
@app.delete("/items/{item_id}")
def delete_item(item_id: int):
    return {"deleted": item_id}
```

ஒவ்வொரு decorator ஒரு HTTP method + path ஐ handler க்கு வரைபடமாக்குகிறது. செயல்பாட்டின் பெயர் உங்களுடையது; decorator route ஐ வரையறுக்கிறது. திரும்பிய dicts/lists/Pydantic models தானாக JSON க்கு தொடரிணக்கம் செய்யப்படுகின்றன — எந்த manual `json.dumps` இல்லை.

## மிகைப்படக் கொண்ட பாதைக்கு வரிசை முக்கியம்

```python
@app.get("/users/me")            # ✅ specific route FIRST
def read_me(): ...
@app.get("/users/{user_id}")     # dynamic AFTER — else "me" matches {user_id}
def read_user(user_id: int): ...
```

FastAPI declaration வரிசையில் routes ஐ பொருத்துகிறது, எனவே static paths ஐ dynamic ones க்கு முன் வையுங்கள்.

## Operation metadata (docs ஐ இயக்குகிறது)

```python
@app.get("/items", tags=["items"], summary="List items", status_code=200)
def list_items(): ...
```

Decorator parameters (`tags`, `summary`, `status_code`, `response_model`) செயல்பாட்டை கட்டமைத்து, தானாக உருவாக்கப்பட்ட documentation ஐ செழுமையாக்குகிறது.

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

Path operations ஒவ்வொரு FastAPI application ன் அடிப்படை — அவை உங்கள் API ன் endpoints ஐ வரையறுக்கும் மற்றும் கோரிக்கைகளை எவ்வாறு கையாளப்படுகிறது என்பதை வரையறுக்கும்.

decorator-per-HTTP-method pattern ஐ புரிந்துகொள்ளுதல், திரும்பிய மதிப்புகள் தானாக JSON க்கு தொடரிணக்கம் செய்யப்படுகின்றன (boilerplate இல்லை), type hints on parameters conversion மற்றும் validation ஐ இயக்குகிறது, மற்றும் route order மிகைப்படக் கொண்ட paths க்கு முக்கியமாகும், எந்த endpoint ஐ கட்டமைப்பதற்கான அத்யாவசியமான தினசரி அறிவு.

Decorator metadata FastAPI ன் தானாக documentation ஐ feed செய்கிறது, routes ஐ நேரடியாக docs க்கு கொண்டு வருகிறது.

இது FastAPI-ல் தொடங்குவதற்கும் மிக நிறைவுள்ளதாக உள்ளது.

ஒவ்வொரு HTTP முறைக்கும் routes ஐ வரையறுத்தல்

மிகைப்படக் கொண்ட பாதைக்கு வரிசை முக்கியம்

Operation metadata (docs ஐ இயக்குகிறது)

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

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