Hur fungerar Django-formulär?

Question

Accepted Answer

Django **formulär** hanterar hela livscykeln för användarinmatning: rendering av HTML-formulärfält, **validering** av inskickad data och konvertering till rena Python-värden. De abstraherar bort det tråkiga, felbenägna arbetet med manuell indatahantering och validering — en viktig produktivitets- och säkerhetsfunktion. ## Ett grundläggande formulär ```python from django import forms class ContactForm(forms.Form): name = forms.CharField(max_length=100) email = forms.EmailField() # validates email format age = forms.IntegerField(min_value=0, required=False) message = forms.CharField(widget=forms.Textarea) ``` Varje formulärfält deklarerar sin typ och valideringsregler. Formuläret kan renderas som HTML och validera inmatning mot dessa regler. ## Hantering av ett formulär i en vy (standardmönstret) ```python def contact(request): if request.method == "POST": form = ContactForm(request.POST) # bind submitted data if form.is_valid(): # run validation # cleaned_data = validated, type-converted Python values name = form.cleaned_data["name"] send_email(form.cleaned_data) return redirect("success") else: form = ContactForm() # empty form for GET return render(request, "contact.html", {"form": form}) ``` De viktigaste metoderna: `is_valid()` kör validering, och vid lyckad validering ger `cleaned_data` dig säkra, validerade, typkonverterade värden. Vid misslyckande behåller formuläret inmatningen och samlar felmeddelanden. ## ModelForms — formulär från modeller (DRY) ```python from django.forms import ModelForm class ArticleForm(ModelForm): class Meta: model = Article # build the form FROM a model fields = ["title", "body", "published"] # which fields to include # ModelForm can SAVE directly to the database def create(request): form = ArticleForm(request.POST) if form.is_valid(): form.save() # creates/updates the model instance! ``` **ModelForms** genererar ett formulär automatiskt från en modells fält och kan spara direkt till databasen — vilket exemplifierar DRY (modellen styr formuläret), och eliminerar standardkod för CRUD-formulär. ## Anpassad validering ```python class SignupForm(forms.Form): password = forms.CharField() confirm = forms.CharField() def clean_password(self): # field-level validation pw = self.cleaned_data["password"] if len(pw) < 8: raise forms.ValidationError("Too short") return pw def clean(self): # form-level (cross-field) validation data = super().clean() if data.get("password") != data.get("confirm"): raise forms.ValidationError("Passwords don't match") ``` ## Rendering och säkerhet ```html ``` Formulär integreras med Djangos **CSRF-skydd** (`{% csrf_token %}`) och renderar automatiskt fält med deras valideringsfel. ## Varför det är viktigt Django-formulär är en kärnfunktion för säker och produktiv hantering av användarinmatning — och att hantera inmatning korrekt är både allomfattande (nästan alla appar har formulär) och säkerhetskritiskt. Det är väsentligt att förstå formulär eftersom de abstraherar bort det tråkiga, felbenägna arbetet med indatahantering: rendering av HTML-fält, **validering** av data mot regler, konvertering till rena typade Python-värden (`cleaned_data`), bevarandet av inmatning och presentationen av fel vid misslyckande, samt skydd mot attacker. Valideringsaspekten är särskilt viktig för **säkerhet och robusthet** — formulär säkerställer att du aldrig litar på rå användarinmatning, och fångar felformulerad eller illasinnad data innan den når din affärslogik. **ModelForms** är en stor produktivitetsvinst, vilket exemplifierar DRY genom att generera formulär direkt från modeller och spara till databasen med minimal kod — och eliminerar standardkod för det extremt vanliga fallet med CRUD-formulär. Att känna till standardvymönstret (`is_valid()` + `cleaned_data`), hur man lägger till anpassad fältnivå- och tvärfältsvalidering, ModelForms för modellstödda formulär, och integreringen med **CSRF-skydd** är grundläggande för att bygga alla Django-applikationer som accepterar användarinmatning. Formulär förbinder indatahantering, validering, säkerhet och modellagret, vilket gör dem till en viktig, ofta använd del av ramverket och en nyckelorsak till att Django är så produktivt för datainmatningstunga applikationer.