Hur hanterar du formulärdata och filöverföringar?

Question

Accepted Answer

FastAPI hanterar HTML **formulärdata** (`Form`) och **filöverföringar** (`File`/`UploadFile`) — skilt från JSON-bodies, eftersom de använder olika innehållstyper (`multipart/form-data`). Båda deklareras med speciella parametertyper.

## Formulärfält

```python
from fastapi import Form

@app.post("/login")
def login(username: str = Form(), password: str = Form()):   # form fields, not JSON
    # data comes as application/x-www-form-urlencoded or multipart/form-data
    return {"username": username}
```

Använd `Form()` för att ta emot HTML-formulärfält (t.ex. ett inloggningsformulär). Notera: en väg kan använda antingen en JSON-body **eller** formulärdata, men inte båda, eftersom de är olika innehållstyper. (Kräver att `python-multipart` är installerat.)

## Filöverföringar

```python
from fastapi import File, UploadFile

@app.post("/upload")
async def upload(file: UploadFile):                  # a single file
    contents = await file.read()                      # read the file's bytes
    file.filename                                      # original name
    file.content_type                                  # MIME type
    # save it:
    with open(f"uploads/{file.filename}", "wb") as f:
        f.write(contents)
    return {"filename": file.filename, "size": len(contents)}
```

`UploadFile` är den rekommenderade typen — det är en buffrad fil (stora filer går till disk, inte allt i minnet), med async-metoder (`read`, `write`, `seek`) och metadata. Använd det i stället för rå `bytes` för allt utom väldigt små filer.

## Flera filer och formulär + fil tillsammans

```python
@app.post("/upload-many")
async def upload_many(files: list[UploadFile]):       # multiple files
    return [f.filename for f in files]

@app.post("/profile")
async def profile(name: str = Form(), avatar: UploadFile = File()):
    # combine form fields AND a file upload in one multipart request
    ...
```

## Validera överföringar (säkerhet!)

```python
if file.content_type not in ["image/jpeg", "image/png"]:   # check type
    raise HTTPException(400, "Invalid file type")
# also: limit file SIZE, sanitize filenames, scan content — uploads are untrusted input
```

## Varför det spelar roll

Att hantera formulärdata och filöverföringar är ett vanligt, praktiskt behov — inloggningsformulär, profilbildsöverföringar, dokumentinskickningar och filbehandlings-API:er kräver allt detta, och det fungerar olika från JSON-bodies som FastAPI använder som standard.

Att förstå `Form()` för formulärfält och särskilt **`UploadFile`** för överföringar (den rekommenderade metoden, eftersom den buffrar stora filer till disk snarare än att ladda allt i minnet — viktigt för att hantera stora filer utan att tömt RAM) är nödvändigt för dessa funktioner.

Lika viktigt är **säkerhetansvaret** som kommer med överföringar: eftersom överförda filer är opålitlig inmatning, är det viktigt att validera deras typ och storlek, sanera filnamn och vara försiktig med hur du lagrar/serverar dem för att undvika säkerhetshål.

Att kunna ta emot formulärfält, hantera enkel- och flerfilsöverföringar, kombinera formulär med filer och validera överföringar på ett säkert sätt är praktisk kunskap för att bygga verkliga API:er som accepterar användaröverförd innehål.