Hvordan fungerer bane- og spørringsparametere?

Question

Accepted Answer

FastAPI trekker ut **baneparametere** (del av URL-banen) og **spørringsparametere** (etter `?`) fra funksjonsargumenter, ved hjelp av typehint for å automatisk konvertere og validere dem.

## Baneparametere — del av 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 funksjonsparameter hvis navn samsvarer med en `{placeholder}` i banen blir en **baneparameter**. Typehint-en (`int`) konverterer automatisk strengen fra URL-en og returnerer en tydelig 422-feil hvis den ikke samsvarer.

## Spørringsparametere — alt annet

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

Funksjonsparametere **som ikke** er i banen blir **spørringsparametere**. En standardverdi gjør dem valgfri (`skip: int = 0`); `str | None = None` gjør en nullbar valgfri spørringsparameter. Uten en standardverdi er de påkrevd.

## Påkrevd versus 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
```

## Kombinere 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 betyr noe

Bane- og spørringsparametere er hvordan endepunkter mottar inndata fra URL-en — grunnleggende for nesten alle API-ruter (henting av en ressurs etter id, filtrering, sideinndeling, søking).

FastAPI-tilnærmingen er elegant og en nøkkelgrunn til at den er produktiv: ved å ganske enkelt deklarere typede funksjonsparametere får du automatisk utvinning, **typekonvertering**, **validering** (med tydelige 422-feil på dårlig inndata) og påkrevd-versus-valgfri semantikk (via standardverdier) — alt utledet fra standard Python-typehints, uten manuell parsing.

Å forstå skillet (baneparametere kommer fra `{placeholders}`, alt annet er en spørringsparameter) og hvordan standardverdier kontrollerer valgfrihet, er viktig hverdagskunnskapen for å bygge FastAPI-endepunkter.