Hoe werken Django-formulieren?

Question

Accepted Answer

Django **formulieren** verwerken de volledige levenscyclus van gebruikersinvoer: het renderen van HTML-formuliervelden, **validatie** van ingediende gegevens, en het omzetten ervan naar schone Python-waarden. Ze abstraheren het saaie, foutgevoelige werk van handmatige invoerverwerking en validatie — een belangrijk productiviteits- en veiligheidskenmerk. ## Een eenvoudig formulier ```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) ``` Elk formulierveld declares zijn type en validatieregels. Het formulier kan zichzelf als HTML renderen en invoer tegen deze regels valideren. ## Een formulier in een view verwerken (het standaardpatroon) ```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 cruciale methoden: `is_valid()` voert validatie uit, en bij succes geeft `cleaned_data` je veilige, gevalideerde, typegeconverteerde waarden. Bij falen behoudt het formulier de invoer en verzamelt foutmeldingen. ## ModelForms — formulieren van modellen (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** genereren automatisch een formulier vanuit de velden van een model en kunnen direct naar de database opslaan — embodying DRY (het model stuurt het formulier), waardoor boilerplate voor CRUD-formulieren wordt geëlimineerd. ## Aangepaste validatie ```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 en beveiliging ```html ``` Formulieren integreren met Django's **CSRF-bescherming** (`{% csrf_token %}`) en renderen velden automatisch met hun validatiefouten. ## Waarom het belangrijk is Django-formulieren zijn een kernfunctie voor het veilig en productief verwerken van gebruikersinvoer — en het correct verwerken van invoer is zowel alomtegenwoordig (vrijwel elke app heeft formulieren) als veiligheidskritiek. Het begrijpen van formulieren is essentieel omdat ze het saaie, foutgevoelige werk van invoerverwerking abstraheren: HTML-velden renderen, **gegevens valideren** tegen regels, het naar schone getypeerde Python-waarden omzetten (`cleaned_data`), invoer behouden en fouten bij falen oppervlakken, en bescherming tegen aanvallen. Het validatieaspect is vooral belangrijk voor **veiligheid en robuustheid** — formulieren zorgen ervoor dat je nooit rauwe gebruikersinvoer vertrouwt, waardoor verkeerd gevormde of kwaadwillige gegevens worden onderschept voordat ze je bedrijfslogica bereiken. **ModelForms** zijn een grote productiviteitswinst, embodying DRY door formulieren rechtstreeks vanuit modellen te genereren en naar de database op te slaan met minimale code — waardoor boilerplate voor het uiterst voorkomende geval van CRUD-formulieren wordt geëlimineerd. Het kennen van het standaard view-patroon (`is_valid()` + `cleaned_data`), hoe je aangepaste veld-niveau en cross-field validatie toevoegt, ModelForms voor modelgestuurde formulieren, en de integratie met **CSRF-bescherming** is fundamenteel voor het bouwen van elke Django-applicatie die gebruikersinvoer accepteert. Formulieren verbinden invoerverwerking, validatie, beveiliging en de modellaag, waardoor ze een belangrijk, veelvuldig gebruikt onderdeel van het framework zijn en een belangrijke reden waarom Django zo productief is voor data-entry-zware applicaties.