阅读: 48562 评论:9


假设你想从表单接收用户名数据,一般情况下,你需要在HTML中手动编写一个如下的表单元素:

  1. <form action="/your-name/" method="post">
  2. <label for="your_name">Your name: </label>
  3. <input id="your_name" type="text" name="your_name" value="{{ current_name }}">
  4. <input type="submit" value="OK">
  5. </form>

这一行定义了我们的发送目的地/your-name/和HTTP方法POST。form元素内部还定义了一个说明标签和一个发送按钮‘submit’,以及最关键的接收用户输入的``元素。具体的更多HTML语言相关内容,请自行学习。

一、编写表单类

我们可以通过Django提供的Form类来自用生成上面的表单,不再需要手动在HTML中编写。

首先,在你当前app内新建一个forms.py文件(这个套路是Django的惯用手法,就像views.pymodels.py等等),然后输入下面的内容:

  1. from django import forms
  2. class NameForm(forms.Form):
  3. your_name = forms.CharField(label='Your name', max_length=100)

要点:

  • 提前导入forms模块
  • 所有的表单类都要继承forms.Form类
  • 每个表单字段都有自己的字段类型比如CharField,它们分别对应一种HTML语言中的``元素中的表单元素。这一点和Django模型系统的设计非常相似。
  • 例子中的label用于设置说明标签
  • max_length限制最大长度为100。它同时起到两个作用,一是在浏览器页面限制用户输入不可超过100个字符,二是在后端服务器验证用户输入的长度不可超过100。

(警告:由于浏览器页面是可以被篡改、伪造、禁用、跳过的,所有的HTML手段的数据验证只能防止意外不能防止恶意行为,是没有安全保证的,破坏分子完全可以跳过浏览器的防御手段伪造发送请求!所以,在服务器后端,必须将前端当做“裸机”来对待,再次进行完全彻底的数据验证和安全防护!)

每个Django表单的实例都有一个内置的is_valid()方法,用来验证接收的数据是否合法。如果所有数据都合法,那么该方法将返回True,并将所有的表单数据转存到它的一个叫做cleaned_data的属性中,该属性是一个字典类型数据。

当我们将上面的表单渲染成真正的HTML元素,其内容如下:

  1. <label for="your_name">Your name: </label>
  2. <input id="your_name" type="text" name="your_name" maxlength="100" required />

一定要注意,它不包含``标签本身以及提交按钮!!!为什么要这样?方便你自己控制表单动作和CSS,JS以及其它类似bootstrap框架的嵌入!

二、视图处理

需要在视图中,实例化我们编写好的表单类。

  1. # views.py
  2. from django.shortcuts import render
  3. from django.http import HttpResponseRedirect
  4. from .forms import NameForm
  5. def get_name(request):
  6. # 如果form通过POST方法发送数据
  7. if request.method == 'POST':
  8. # 接受request.POST参数构造form类的实例
  9. form = NameForm(request.POST)
  10. # 验证数据是否合法
  11. if form.is_valid():
  12. # 处理form.cleaned_data中的数据
  13. # ...
  14. # 重定向到一个新的URL
  15. return HttpResponseRedirect('/thanks/')
  16. # 如果是通过GET方法请求数据,返回一个空的表单
  17. else:
  18. form = NameForm()
  19. return render(request, 'name.html', {'form': form})

要点是:

  • 对于GET方法请求页面时,返回空的表单,让用户可以填入数据;
  • 对于POST方法,接收表单数据,并验证;
  • 如果数据合法,按照正常业务逻辑继续执行下去;
  • 如果不合法,返回一个包含先前数据的表单给前端页面,方便用户修改。

通过表单的is_bound属性可以获知一个表单已经绑定了数据,还是一个空表。

三、模板处理

在Django的模板中,我们只需要按下面处理,就可以得到完整的HTML页面:

  1. <form action="/your-name/" method="post">
  2. {% csrf_token %}
  3. {{ form }}
  4. <input type="submit" value="Submit" />
  5. </form>

要点:

  • ...标签要自己写;
  • 使用POST的方法时,必须添加{% csrf_token %}标签,用于处理csrf安全机制;
  • {{ form }}代表Django为你生成其它所有的form标签元素,也就是我们上面做的事情;
  • 提交按钮需要手动添加!

提示:默认情况下,Django支持HTML5的表单验证功能,比如邮箱地址验证、必填项目验证等等。

四、高级技巧

上面的例子中,只有一个用户名输入框,太简单了,实际上有更多的表单元素。看下面的例子:

  1. from django import forms
  2. class ContactForm(forms.Form):
  3. subject = forms.CharField(max_length=100)
  4. message = forms.CharField(widget=forms.Textarea)
  5. sender = forms.EmailField()
  6. cc_myself = forms.BooleanField(required=False)

这个例子就有4个框组了。实际上Django的表单模块为我们内置了许多表单字段,如下所示:

  • BooleanField
  • CharField
  • ChoiceField
  • TypedChoiceField
  • DateField
  • DateTimeField
  • DecimalField
  • DurationField
  • EmailField
  • FileField
  • FilePathField
  • FloatField
  • ImageField
  • IntegerField
  • GenericIPAddressField
  • MultipleChoiceField
  • TypedMultipleChoiceField
  • NullBooleanField
  • RegexField
  • SlugField
  • TimeField
  • URLField
  • UUIDField
  • ComboField
  • MultiValueField
  • SplitDateTimeField
  • ModelChoiceField
  • ModelMultipleChoiceField

每一个表单字段类型都对应一种Widget类,每一种Widget类都对应了HMTL语言中的一种input元素类型,比如。需要在HTML中实际使用什么类型的input,就需要在Django的表单字段中选择相应的field。比如要一个,可以选择一个CharField

一旦你的表单接收数据并验证通过了,那么就可以从form.cleaned_data字典中读取所有的表单数据,下面是一个例子:

  1. # views.py
  2. from django.core.mail import send_mail
  3. if form.is_valid():
  4. subject = form.cleaned_data['subject']
  5. message = form.cleaned_data['message']
  6. sender = form.cleaned_data['sender']
  7. cc_myself = form.cleaned_data['cc_myself']
  8. recipients = ['info@example.com']
  9. if cc_myself:
  10. recipients.append(sender)
  11. send_mail(subject, message, sender, recipients)
  12. return HttpResponseRedirect('/thanks/')

五、 使用表单模板

1.表单渲染格式

前面我们通过{{ form }}模板语言,简单地将表单渲染到HTML页面中了,实际上,有更多的方式:

  • {{ form.as_table }} 将表单渲染成一个表格元素,每个输入框作为一个标签
  • {{ form.as_p }} 将表单的每个输入框包裹在一个``标签内 tags
  • {{ form.as_ul }} 将表单渲染成一个列表元素,每个输入框作为一个``标签

注意:你要自己手动编写标签。

下面是将上面的ContactForm作为{{ form.as_p }}的例子:

  1. <p><label for="id_subject">Subject:</label>
  2. <input id="id_subject" type="text" name="subject" maxlength="100" required /></p>
  3. <p><label for="id_message">Message:</label>
  4. <textarea name="message" id="id_message" required></textarea></p>
  5. <p><label for="id_sender">Sender:</label>
  6. <input type="email" name="sender" id="id_sender" required /></p>
  7. <p><label for="id_cc_myself">Cc myself:</label>
  8. <input type="checkbox" name="cc_myself" id="id_cc_myself" /></p>

注意:Django自动为每个input元素设置了一个id名称,对应label的for参数。

2.手动渲染表单字段

直接{{ form }}虽然好,啥都不用操心,但是往往并不是你想要的,比如你要使用CSS和JS,比如你要引入Bootstarps框架,这些都需要对表单内的input元素进行额外控制,那怎么办呢?手动渲染字段就可以了。

可以通过{{ form.name_of_field }}获取每一个字段,然后分别渲染,如下例所示:

  1. {{ form.non_field_errors }}
  2. <div class="fieldWrapper">
  3. {{ form.subject.errors }}
  4. <label for="{{ form.subject.id_for_label }}">Email subject:</label>
  5. {{ form.subject }}
  6. </div>
  7. <div class="fieldWrapper">
  8. {{ form.message.errors }}
  9. <label for="{{ form.message.id_for_label }}">Your message:</label>
  10. {{ form.message }}
  11. </div>
  12. <div class="fieldWrapper">
  13. {{ form.sender.errors }}
  14. <label for="{{ form.sender.id_for_label }}">Your email address:</label>
  15. {{ form.sender }}
  16. </div>
  17. <div class="fieldWrapper">
  18. {{ form.cc_myself.errors }}
  19. <label for="{{ form.cc_myself.id_for_label }}">CC yourself?</label>
  20. {{ form.cc_myself }}
  21. </div>

其中的label标签甚至可以用label_tag()方法来生成,于是可以简写成下面的样子:

  1. <div class="fieldWrapper">
  2. {{ form.subject.errors }}
  3. {{ form.subject.label_tag }}
  4. {{ form.subject }}
  5. </div>

这样子是不是更加灵活了呢?但是灵活的代价就是我们要写更多的代码,又偏向原生的HTML代码多了一点。

3. 渲染表单错误信息:

注意上面的例子中,我们使用{{ form.name_of_field.errors }}模板语法,在表单里处理错误信息。对于每一个表单字段的错误,它其实会实际生成一个无序列表,参考下面的样子:

  1. <ul class="errorlist">
  2. <li>Sender is required.</li>
  3. </ul>

这个列表有个默认的CSS样式类errorlist,如果你想进一步定制这个样式,可以循环错误列表里的内容,然后单独设置样式:

  1. {% if form.subject.errors %}
  2. <ol>
  3. {% for error in form.subject.errors %}
  4. <li><strong>{{ error|escape }}</strong></li>
  5. {% endfor %}
  6. </ol>
  7. {% endif %}

一切非字段的错误信息,比如表单的错误,隐藏字段的错误都保存在{{ form.non_field_errors }}中,上面的例子,我们把它放在了表单的外围上面,它将被按下面的HTML和CSS格式渲染:

  1. <ul class="errorlist nonfield">
  2. <li>Generic validation error</li>
  3. </ul>

4. 循环表单的字段:

如果你的表单字段有相同格式的HMTL表现,那么完全可以循环生成,不必要手动的编写每个字段,减少冗余和重复代码,只需要使用模板语言中的{% for %}循环,如下所示:

  1. {% for field in form %}
  2. <div class="fieldWrapper">
  3. {{ field.errors }}
  4. {{ field.label_tag }} {{ field }}
  5. {% if field.help_text %}
  6. <p class="help">{{ field.help_text|safe }}</p>
  7. {% endif %}
  8. </div>
  9. {% endfor %}

下表是{{ field }}中非常有用的属性,这些都是Django内置的模板语言给我们提供的方便:

属性 说明
{{ field.label }} 字段对应的label信息
{{ field.label_tag }} 自动生成字段的label标签,注意与{{ field.label }}的区别。
{{ field.id_for_label }} 自定义字段标签的id
{{ field.value }} 当前字段的值,比如一个Email字段的值someone@example.com
{{ field.html_name }} 指定字段生成的input标签中name属性的值
{{ field.help_text }} 字段的帮助信息
{{ field.errors }} 包含错误信息的元素
{{ field.is_hidden }} 用于判断当前字段是否为隐藏的字段,如果是,返回True
{{ field.field }} 返回字段的参数列表。例如{{ char_field.field.max_length }}

5. 不可见字段的特殊处理:

很多时候,我们的表单中会有一些隐藏的不可见的字段,比如honeypot。我们需要让它在任何时候都仿佛不存在一般,比如有错误的时候,如果你在页面上显示了不可见字段的错误信息,那么用户会很迷惑,这是哪来的呢?所以,通常我们是不显示不可见字段的错误信息的。

Django提供了两种独立的方法,用于循环那些不可见的和可见的字段,hidden_fields()visible_fields()。这里,我们可以稍微修改一下前面的例子:

  1. {# 循环那些不可见的字段 #}
  2. {% for hidden in form.hidden_fields %}
  3. {{ hidden }}
  4. {% endfor %}
  5. {# 循环可见的字段 #}
  6. {% for field in form.visible_fields %}
  7. <div class="fieldWrapper">
  8. {{ field.errors }}
  9. {{ field.label_tag }} {{ field }}
  10. </div>
  11. {% endfor %}

6. 重用表单模板

如果你在自己的HTML文件中,多次使用同一种表单模板,那么你完全可以把表单模板存成一个独立的HTML文件,然后在别的HTML文件中通过include模板语法将其包含进来,如下例所示:

  1. # 实际的页面文件中:
  2. {% include "form_snippet.html" %}
  3. -----------------------------------------------------
  4. # 单独的表单模板文件form_snippet.html:
  5. {% for field in form %}
  6. <div class="fieldWrapper">
  7. {{ field.errors }}
  8. {{ field.label_tag }} {{ field }}
  9. </div>
  10. {% endfor %}

如果你的页面同时引用了好几个不同的表单模板,那么为了防止冲突,你可以使用with参数,给每个表单模板取个别名,如下所示:

  1. {% include "form_snippet.html" with form=comment_form %}

在使用的时候就是:

  1. {% for field in comment_form %}
  2. ......

如果你经常做这些重用的工作,建议你考虑自定义一个内联标签,这已经是Django最高级的用法了。