From the source code, you can see that Django 1.4's Form
class has a has_changed()
method and changed_data
property which seem rather useful, but are undocumented. My question is: do these work as expected, i.e.:
Form.clean()
, Form.has_changed()
returns True
if any any form data has changed, otherwise False
Form.clean()
, Form.changed_data
is a list of field names whose values have changed.If so, are there any specific reasons not to use them, apart from the usual caveats/dangers about using undocumented features (i.e. subject to change, not supported, etc.)?
NOTE 1: For these to work with custom widgets, those widgets need to have a _has_changed()
method, which is defined for built in widgets.
NOTE 2: Interestingly, the documentation does include an offhand mention of the Formset.has_changed()
method, but not of Form.has_changed()
.
The is_valid() method is used to perform validation for each field of the form, it is defined in Django Form class. It returns True if data is valid and place all data into a cleaned_data attribute.
{{ form. as_p }} – Render Django Forms as paragraph.
Use the has_changed() method on your Form when you need to check if the form data has been changed from the initial data. has_changed() will be True if the data from request.
form. cleaned_data returns a dictionary of validated form input fields and their values, where string primary keys are returned as objects. form. data returns a dictionary of un-validated form input fields and their values in string format (i.e. not objects).
After studying the Django source further, with helpful hints from Florian's answer, I can report that has_changed
and changed_data
do work as described in my question as long as the form has a way to get the initial data to compare the new data against.
So the question is, how does a form created from POST data know what the initial values of the GET form were? The short answer is it doesn't -- unless you tell it somehow. There are two ways to tell it:
Via the initial
keyword argument to the form and/or the initial
keyword arguments to the fields, exactly the same way you tell the GET form the initial values. NOTE: If you do this, it's up to you to make sure you use the same values for your GET and POST forms. This is the only truly reliable way to do it, since you directly control what the initial values are.
You let Django do the work of remembering the initial values from your GET by setting the show_hidden_initial
keyword argument to True
for each applicable field. For these fields, Django renders a hidden input element with the initial value into the GET form's HTML. Later, when you call has_changed
or changed_data
on the POST form, for any field with show_hidden_initial
as True
Django will automatically get the initial values from the hidden input elements in the POST data (superseding any initial values from initial
form or field arguments). NOTE: as with anything relying on POST data, this approach is ultimately unreliable, since the values for the hidden inputs could still be changed despite being hidden.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With