Django forms எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

Django **forms** பயனர் உள்ளீட்டின் முழு வாழ்க்கைச் சுழற்சியைக் கையாளுகிறது: HTML form fields ஐ render செய்தல், **validation** செய்தல், மற்றும் அதை clean Python values ஆக மாற்றுதல். அவை manual input handling மற்றும் validation இன் சோர்வாக, error-prone வேலையை abstract செய்கிறது — ஒரு முக்கிய productivity மற்றும் security feature. ## ஒரு basic form ```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) ``` ஒவ்வொரு form field அதன் type மற்றும் validation rules ஐ declare செய்கிறது. form தன்னை HTML ஆக render செய்யக்கூடும் மற்றும் அந்த rules க்கு எதிராக input ஐ validate செய்யக்கூடும். ## View இல் ஒரு form ஐ handling செய்தல் (the standard pattern) ```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}) ``` Key methods: `is_valid()` validation ஐ run செய்கிறது, மற்றும் success இல் `cleaned_data` safe, validated, type-converted values ஐ உங்களுக்கு வழங்குகிறது. Failure இல், form input ஐ retain செய்கிறது மற்றும் error messages ஐ collect செய்கிறது. ## ModelForms — models இலிருந்து forms (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** ஒரு model இன் fields இலிருந்து தானாகவே ஒரு form ஐ generate செய்கிறது மற்றும் database இற்கு நேரடியாக save செய்யக்கூடும் — DRY (the model drives the form) ஐ embodying செய்கிறது, CRUD forms க்கான boilerplate ஐ eliminate செய்கிறது. ## Custom validation ```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 மற்றும் security ```html ``` Forms Django இன் **CSRF protection** (`{% csrf_token %}`) உடன் integrate செய்யப்பட்டுள்ளது மற்றும் fields ஐ அவற்றின் validation errors உடன் auto-render செய்கிறது. ## ஏன் இது முக்கியமானது Django forms பயனர் உள்ளீட்டை safely மற்றும் productively handling செய்வதற்கான ஒரு core feature ஆகும் — மற்றும் input ஐ correctly handling செய்வது ubiquitous (nearly every app forms ஐ கொண்டுள்ளது) மற்றும் security-critical ஆகும். Forms ஐ புரிந்துகொள்வது essential ஆகும் ஏனெனில் அவை input handling இன் சோர்வாக, error-prone வேலையை abstract செய்கிறது: HTML fields ஐ rendering செய்தல், rules க்கு எதிராக data ஐ **validating** செய்தல், அதை clean typed Python values ஆக மாற்றுதல் (`cleaned_data`), failure இல் input ஐ preserve செய்தல் மற்றும் errors ஐ surface செய்தல், மற்றும் attacks இலிருந்து protect செய்தல். Validation aspect **security மற்றும் robustness** க்கு especially important ஆகும் — forms உங்கள் business logic ஐ reach செய்வதற்கு முன் raw user input ஐ நிறைய நம்ப வேண்டாம் என்பதை உறுதிசெய்கிறது, malformed அல்லது malicious data ஐ catching செய்கிறது. **ModelForms** ஒரு major productivity win ஆகும், models இலிருந்து directly forms ஐ generate செய்வதன் மூலம் DRY ஐ embodying செய்கிறது மற்றும் minimal code உடன் database இற்கு saving செய்கிறது — CRUD forms இன் extremely common case க்கான boilerplate ஐ eliminate செய்கிறது. Standard view pattern (`is_valid()` + `cleaned_data`) ஐ அறிந்துகொள்வது, custom field-level மற்றும் cross-field validation ஐ கூட்டுவது எப்படி, model-backed forms க்கான ModelForms, மற்றும் **CSRF protection** உடன் integration ஐ அறிந்துகொள்வது பயனர் உள்ளீட்டை accept செய்யும் எந்த Django application ஐயும் build செய்வதற்கான fundamental ஆகும். Forms input handling, validation, security, மற்றும் model layer ஐ tie செய்கிறது, அவற்றை framework இன் ஒரு important, frequently-used part ஆக்குகிறது மற்றும் Django data-entry-heavy applications க்கான productivity க்கான ஒரு key reason ஆக்குகிறது.