Hvordan fungerer Django-formularer?

Question

Accepted Answer

Django **formularer** håndterer hele livscyklussen for brugerinput: rendering af HTML-formularfelter, **validering** af indsendte data og konvertering til rene Python-værdier. De abstraherer det kedelige, fejltilbøjeligt arbejde med manuel inputhåndtering og validering – en vigtig produktivitets- og sikkerhedsfunktion. ## En grundlæggende formular ```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) ``` Hvert formularfelt deklarerer sin type og valideringsregler. Formularen kan gengive sig selv som HTML og validere input mod disse regler. ## Håndtering af en formular i en view (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}) ``` Nøglemetoderne: `is_valid()` kører validering, og ved succes giver `cleaned_data` dig sikre, validerede, type-konverterede værdier. Ved fejl bevarer formularen inputtet og samler fejlmeddelelser. ## ModelForms – formularer fra 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** genererer en formular automatisk ud fra en models felter og kan gemme direkte til databasen – der udmønter DRY (modellen driver formularen), hvilket eliminerer standardkode til CRUD-formularer. ## Brugerdefineret 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 og sikkerhed ```html ``` Formularer integreres med Djangos **CSRF-beskyttelse** (`{% csrf_token %}`) og gengiver automatisk felter med deres valideringsfejl. ## Hvorfor det betyder noget Django-formularer er en kernefunktion til sikker og produktiv håndtering af brugerinput – og korrekt inputhåndtering er både allestedsnærværende (næsten alle apps har formularer) og kritisk for sikkerheden. Forståelse af formularer er vigtig, fordi de abstraherer det kedelige, fejltilbøjeligt arbejde med inputhåndtering: rendering af HTML-felter, **validering** af data mod regler, konvertering til rene typede Python-værdier (`cleaned_data`), bevaring af input og visning af fejl ved fiasko, og beskyttelse mod angreb. Valideringaspektet er særlig vigtig for **sikkerhed og robusthed** – formularer sikrer, at du aldrig stoler på rå brugerinput, hvilket fanger dårligt formatteret eller ondsindet data, før det når din forretningslogik. **ModelForms** er et stort produktivitetsgevinst, der udmønter DRY ved at generere formularer direkte fra modeller og gemme til databasen med minimal kode – hvilket eliminerer standardkode til det yderst almindelige tilfælde af CRUD-formularer. At kende standardview-mønstret (`is_valid()` + `cleaned_data`), hvordan man tilføjer brugerdefineret felt-niveau og tværfelt-validering, ModelForms til modelgestützede formularer, og integrationen med **CSRF-beskyttelse** er grundlæggende for at bygge enhver Django-applikation, der accepterer brugerinput. Formularer forbinder inputhåndtering, validering, sikkerhed og modellaget og gør dem til en vigtig, hyppigt brugt del af frameworket og en nøgleårsag til, at Django er så produktivt for datainputintensive applikationer.