როგორ მუშაობს გზის პარამეტრები და მოთხოვნის პარამეტრები?

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 ბოლო წერტილების აგების ყოველდღიური ცოდნა.