પાથ અને ક્વેરી પરિમાણો કેવી રીતે કાર્ય કરે છે?

Question

Accepted Answer

FastAPI ફંક્શન આર્ગ્યુમેન્ટ્સમાંથી **પાથ પરિમાણો** (URL પાથનો ભાગ) અને **ક્વેરી પરિમાણો** (`?` પછી) કાઢે છે, તેમને આપોઆપ રૂપાંતર અને માન્ય કરવા માટે પ્રકાર સંકેતનો ઉપયોગ કરે છે।

## પાથ પરિમાણો — URL નો ભાગ

```python
@app.get("/items/{item_id}")        # {item_id} in the path
def get_item(item_id: int):          # matched by NAME; `int` converts & validates
    return {"item_id": item_id}
# GET /items/5 → item_id = 5 (int).  GET /items/abc → 422 error (not an int)
```

પાથમાં `{placeholder}` સાથે મેળ ખાતું નામ ધરાવતું ફંક્શન પરિમાણ એક **પાથ પરિમાણ** બને છે। પ્રકાર સંકેત (`int`) URL માંથી સ્ટ્રિંગને આપોઆપ રૂપાંતરિત કરે છે અને તે મેળ ન ખાતું હોય તો સ્પષ્ટ 422 ભૂલ આપે છે।

## ક્વેરી પરિમાણો — બાકી બધું

```python
@app.get("/items")
def list_items(skip: int = 0, limit: int = 10, q: str | None = None):
    # parameters NOT in the path become QUERY parameters
    # GET /items?skip=20&limit=5&q=phone → skip=20, limit=5, q="phone"
    return {"skip": skip, "limit": limit, "q": q}
```

પાથમાં **નહીં** હોય તેવા ફંક્શન પરિમાણો **ક્વેરી પરિમાણો** બની જાય છે। ડિફૉલ્ટ વેલ્યુ તેમને વૈકલ્પિક બનાવે છે (`skip: int = 0`) ; `str | None = None` એક શૂન્ય વૈકલ્પિક ક્વેરી પરિમાણ બનાવે છે। ડિફૉલ્ટ વિના, તેઓ જરૂરી છે।

## આવશ્યક વર્ષ વૈકલ્પિક

```python
def search(q: str):              # REQUIRED query param (no default) → ?q=... must be present
def search(q: str = ""):          # optional, defaults to ""
def search(q: str | None = None): # optional, defaults to None
```

## બંને ને સંયોજન કરવું

```python
@app.get("/users/{user_id}/items")
def user_items(user_id: int, limit: int = 10):
    # user_id = path param, limit = query param — distinguished by the path
```

## તે શા માટે મહત્ત્વપૂર્ણ છે

પાથ અને ક્વેરી પરિમાણો એ છે કે કેવી રીતે એન્ડપોઇન્ટ્સ URL માંથી ઇનપુટ પ્રાપ્ત કરે છે — લગભગ દરેક API માર્ગ માટે મૌલિક (ID દ્વારા સંસાધન લાવવું, ફિલ્ટર કરવું, પેજિંગ, શોધવું)।

FastAPI ની પદ્ધતિ ચોક્કસ અને તે ઉત્પાદક હોવાનું કારણ છે: સાધારણ રીતે ટાઇપ કરેલ ફંક્શન પરિમાણો જાહેર કરવાથી તમને આપોઆપ નિષ્કર્ષણ, **પ્રકાર રૂપાંતર**, **માન્યતા** (ખરાબ ઇનપુટ પર સ્પષ્ટ 422 ભૂલો સાથે) અને આવશ્યક-વર્ષ-વૈકલ્પિક સંદર્ભશાસ્ત્ર (ડિફૉલ્ટ્સ દ્વારા) — તમામ પ્રમાણભૂત Python પ્રકાર સંકેતો માંથી વ્યુત્પન્ન, કોઈ જાતીય પાર્સિંગ વિના।

વિભેદ (પાથ પરિમાણો `{placeholders}` માંથી આવે છે, બાકી બધું એક ક્વેરી પરિમાણ છે) અને ડિફૉલ્ટ્સ કેવી રીતે વૈકલ્પિકતા નિયંત્રિત કરે છે તે સમજવું FastAPI એન્ડપોઇન્ટ્સ બનાવવા માટે દૈનિક આવશ્યક જ્ઞાન છે।