Hvordan fungerer sti- og forespørgselsparametre?

Question

Accepted Answer

FastAPI udtrækker **stiparametre** (del af URL-stien) og **forespørgselsparametre** (efter `?`) fra funktionsargumenter ved hjælp af typeanvisninger til automatisk konvertering og validering.

## Stiparametre — del af URL'en

```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)
```

En funktionsparameter, hvis navn matcher en `{placeholder}` i stien, bliver en **stiparameter**. Typeanvisningen (`int`) konverterer automatisk strengen fra URL'en og returnerer en klar 422-fejl, hvis den ikke stemmer.

## Forespørgselsparametre — alt andet

```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}
```

Funktionsparametre **ikke** i stien bliver **forespørgselsparametre**. En standardværdi gør dem valgfri (`skip: int = 0`); `str | None = None` gør en nullable valgfri forespørgselsparameter. Uden standardværdi er de påkrævede.

## Påkrævet vs valgfri

```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
```

## Kombination af begge

```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
```

## Hvorfor det er vigtig

Sti- og forespørgselsparametre er, hvordan slutpunkter modtager input fra URL'en — grundlæggende for næsten enhver API-rute (hent en ressource efter id, filtrering, paginering, søgning).

FastAPI's tilgang er elegant og en nøglegrund til dets produktivitet: ved simpelthen at deklarere typede funktionsparametre får du automatisk udtrækning, **typekonvertering**, **validering** (med klare 422-fejl ved dårligt input) og påkrævet-vs-valgfri-semantik (via standardværdier) — alt afledt fra standard Python-typeanvisninger, uden manuel parsing.

At forstå sondringen (stiparametre kommer fra `{placeholders}`, alt andet er en forespørgselsparameter) og hvordan standardværdier kontrollerer valgfrihed, er væsentlig daglig viden for at bygge FastAPI-slutpunkter.