Come funzionano i form in Django?

Question

Accepted Answer

I **form** Django gestiscono l'intero ciclo di vita dell'input dell'utente: rendering dei campi form HTML, **validazione** dei dati inviati e conversione in valori Python puliti. Astraggono il lavoro tedioso e soggetto a errori della gestione manuale dell'input e della validazione — una caratteristica importante per la produttività e la sicurezza. ## Un form di base ```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) ``` Ogni campo form dichiara il suo tipo e le regole di validazione. Il form può renderizzarsi come HTML e validare l'input rispetto a quelle regole. ## Gestire un form in una view (il pattern standard) ```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}) ``` I metodi chiave: `is_valid()` esegue la validazione, e al successo `cleaned_data` ti fornisce valori sicuri, validati e convertiti di tipo. Al fallimento, il form mantiene l'input e raccoglie i messaggi di errore. ## ModelForms — form da modelli (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! ``` I **ModelForms** generano automaticamente un form dai campi di un modello e possono salvare direttamente nel database — incarnando il principio DRY (il modello guida il form), eliminando il boilerplate per i form CRUD. ## Validazione personalizzata ```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 e sicurezza ```html ``` I form si integrano con la **protezione CSRF** di Django (`{% csrf_token %}`) e renderizzano automaticamente i campi con i loro messaggi di validazione. ## Perché è importante I form Django sono una caratteristica fondamentale per gestire l'input dell'utente in modo sicuro e produttivo — e gestire l'input correttamente è sia ubiquitario (praticamente ogni app ha form) che critico per la sicurezza. Comprendere i form è essenziale perché astraggono il lavoro tedioso e soggetto a errori della gestione dell'input: rendering dei campi HTML, **validazione** dei dati rispetto alle regole, conversione in valori Python tipizzati e puliti (`cleaned_data`), conservazione dell'input e visualizzazione degli errori al fallimento, e protezione contro gli attacchi. L'aspetto di validazione è particolarmente importante per la **sicurezza e la robustezza** — i form garantiscono che tu non dia mai fiducia all'input grezzo dell'utente, catturando dati malformati o malevoli prima che raggiungano la tua logica di business. I **ModelForms** sono una vittoria importante per la produttività, incarnando il principio DRY generando form direttamente dai modelli e salvando nel database con un codice minimo — eliminando il boilerplate per il caso estremamente comune dei form CRUD. Conoscere il pattern standard delle view (`is_valid()` + `cleaned_data`), come aggiungere validazione personalizzata a livello di campo e cross-field, ModelForms per form supportati da modelli, e l'integrazione con la **protezione CSRF** è fondamentale per costruire qualsiasi applicazione Django che accetti input dell'utente. I form legano insieme la gestione dell'input, la validazione, la sicurezza e il livello del modello, rendendoli una parte importante e frequentemente utilizzata del framework e una ragione chiave per cui Django è così produttivo per applicazioni pesanti di immissione dati.