Techniques for Field Validation in Django

Django form data verification is a key link for Web development to ensure that the collected user data meets the application needs. Django provides a variety of field verification methods, which will gradually explain this article.

1. Use field parameters

When defining the Django table field, you can usually specify the verification rules directly through the field parameters.

For example, ensure that the maximum length of the

field is 100 characters. Since it is first_name, you can use CharField Parameters: max_length

<code class="language-python">from django import forms

class PersonalInfo(forms.Form):
    first_name = forms.CharField(max_length=100)</code>

This is one of the simplest and most commonly used verification methods.

2. Use the built -in verification device

Django's built -in verification device is a reusable callable object to perform specific verification inspections.

Assume that the minimum value of the

field is 18. Although the parameters can be used directly, how to use the age: min_value MinValueValidator

Django's

<code class="language-python">from django import forms
from django.core.validators import MinValueValidator

class PersonalInfo(forms.Form):
    first_name = forms.CharField(max_length=100)
    age = forms.IntegerField(validators=[MinValueValidator(18)])</code>

module provides multiple pre -constructed verifications for minimum/maximum value inspection, regular expression verification and other tasks.

validators

Writing a custom verification device
Sometimes, more complicated verification logic is needed, and the built -in verification device cannot be processed. In this case, you can write a custom verification device.

The verification device is a callable object. It receives a value. If the value does not meet the conditions, it will cause

. For example, create a verification device to ensure the number of numbers:

ValidationError

Tip:

<code class="language-python">from django import forms
from django.core.exceptions import ValidationError
from django.core.validators import MinValueValidator

def validate_even(value):
    if value % 2 != 0:
        raise ValidationError(f"{value} 不是偶数")

class PersonalInfo(forms.Form):
    first_name = forms.CharField(max_length=100)
    age = forms.IntegerField(validators=[MinValueValidator(18)])
    even_field = forms.IntegerField(validators=[validate_even])</code>

In order to keep the code orderly, you can consider putting the custom verification device in a separate file, such as

. This depends on the scale of the project. validators.py

Use Method

4. clean_<fieldname>() Another powerful field verification method is to rewrite the

   method in the form class. This method is particularly suitable for verification logic specific to a single form.

For example, verify the

field directly in the form: clean_<fieldname>()

This method can directly access the cleaning data of the field and allow more detailed control verification. even_field

<code class="language-python">from django import forms
from django.core.exceptions import ValidationError
from django.core.validators import MinValueValidator

class PersonalInfo(forms.Form):
    first_name = forms.CharField(max_length=100)
    age = forms.IntegerField(validators=[MinValueValidator(18)])
    even_field = forms.IntegerField()

    def clean_even_field(self):
        even_field_validated = self.cleaned_data.get("even_field")
        if even_field_validated % 2 != 0:
            raise ValidationError(f"{even_field_validated} 不是偶数")
        return even_field_validated</code>

Method

5. Sometimes, verification needs to consider the relationship between multiple fields in the form. For example, if there are two fields, there are more characters in one field than another field. This type of verification is clean() Form -level verification

   , because it depends on the value of multiple fields, not just a single field.

For this reason, you can rewrite the

method in the form class.

By rewriting the method, you can realize the custom logic logic of the entire form to ensure that the data meets more complicated requirements.

clean() Summary

Django provides multiple form verification methods:

<code class="language-python">from django import forms
from django.core.exceptions import ValidationError
from django.core.validators import MinValueValidator

class PersonalInfo(forms.Form):
    first_name = forms.CharField(max_length=100)
    age = forms.IntegerField(validators=[MinValueValidator(18)])
    even_field = forms.IntegerField()
    field1 = forms.CharField()
    field2 = forms.CharField()

    def clean_even_field(self):
        even_field_validated = self.cleaned_data.get("even_field")
        if even_field_validated % 2 != 0:
            raise ValidationError(f"{even_field_validated} 不是偶数")
        return even_field_validated

    def clean(self):  # 表单级验证
        cleaned_data = super().clean()
        field1_value = cleaned_data.get("field1")
        field2_value = cleaned_data.get("field2")

        if field1_value and field2_value and len(field1_value) >= len(field2_value):
            raise ValidationError("field2 字符数必须多于 field1.")
        return cleaned_data</code>

• Field parameters: Use max_length or min_value and other parameters for simple verification.
• Built -in verification device: Use Django's predetermined verification device to handle common mode.
• Custom verification device: Written reusable callable objects for complex verification rules.
• Method: Rewrite this method for high -level specific field verification. clean_<fieldname>()
Method: Use this method to perform form -level verification involving multiple fields.
• clean()

The above is the detailed content of Techniques for Field Validation in Django. For more information, please follow other related articles on the PHP Chinese website!