How to Use a Form without a Data Class
In most cases, a form is tied to an object, and the fields of the form get and store their data on the properties of that object. This is what the main article on forms is about.
But sometimes, you may want to use a form without a class, and get back an
array of the submitted data. The getData()
method allows you to do
exactly that:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
// src/Controller/ContactController.php
namespace App\Controller;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
// ...
class ContactController extends AbstractController
{
public function contact(Request $request): Response
{
$defaultData = ['message' => 'Type your message here'];
$form = $this->createFormBuilder($defaultData)
->add('name', TextType::class)
->add('email', EmailType::class)
->add('message', TextareaType::class)
->add('send', SubmitType::class)
->getForm();
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
// data is an array with "name", "email", and "message" keys
$data = $form->getData();
}
// ... render the form
}
}
By default, a form actually assumes that you want to work with arrays of data, instead of an object. There are exactly two ways that you can change this behavior and tie the form to an object instead:
- Pass an object when creating the form (as the first argument to
createFormBuilder()
or the second argument tocreateForm()
); - Declare the
data_class
option on your form.
If you don't do either of these, then the form will return the data as
an array. In this example, since $defaultData
is not an object (and
no data_class
option is set), $form->getData()
ultimately returns
an array.
Tip
You can also access POST values (in this case "name") directly through the request object, like so:
1
$request->getPayload()->get('name');
Be advised, however, that in most cases using the getData()
method is
a better choice, since it returns the data (usually an object) after
it's been transformed by the Form component.
Adding Validation
The only missing piece is validation. Usually, when you call $form->handleRequest($request)
,
the object is validated by reading the constraints that you applied to that
class. If your form is mapped to an object (i.e. you're using the data_class
option or passing an object to your form), this is almost always the approach
you want to use. See Validation for more details.
But if the form is not mapped to an object and you instead want to retrieve an array of your submitted data, how can you add constraints to the data of your form?
Constraints At Field Level
One possibility is to set up the constraints yourself, and attach them to the individual fields. The overall approach is covered a bit more in this validation article, but here's a short example:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\Validator\Constraints\Length;
use Symfony\Component\Validator\Constraints\NotBlank;
public function buildForm(FormBuilderInterface $builder, array $options): void
{
$builder
->add('firstName', TextType::class, [
'constraints' => new Length(['min' => 3]),
])
->add('lastName', TextType::class, [
'constraints' => [
new NotBlank(),
new Length(['min' => 3]),
],
])
;
}
Tip
If you are using validation groups, you need to either reference the
Default
group when creating the form, or set the correct group on
the constraint you are adding:
1
new NotBlank(['groups' => ['create', 'update']]);
Tip
If the form is not mapped to an object, every object in your array of
submitted data is validated using the Symfony
constraint, unless you disable validation.
Caution
When a form is only partially submitted (for example, in an HTTP PATCH request), only the constraints from the submitted form fields will be evaluated.
Constraints At Class Level
Another possibility is to add the constraints at the class level.
This can be done by setting the constraints
option in the
configureOptions()
method:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\Validator\Constraints\Length;
use Symfony\Component\Validator\Constraints\NotBlank;
public function buildForm(FormBuilderInterface $builder, array $options): void
{
$builder
->add('firstName', TextType::class)
->add('lastName', TextType::class);
}
public function configureOptions(OptionsResolver $resolver): void
{
$constraints = [
'firstName' => new Length(['min' => 3]),
'lastName' => [
new NotBlank(),
new Length(['min' => 3]),
],
];
$resolver->setDefaults([
'data_class' => null,
'constraints' => $constraints,
]);
}
This means you can also do this when using the createFormBuilder()
method
in your controller:
1 2 3 4 5 6 7 8 9 10 11 12
$form = $this->createFormBuilder($defaultData, [
'constraints' => [
'firstName' => new Length(['min' => 3]),
'lastName' => [
new NotBlank(),
new Length(['min' => 3]),
],
],
])
->add('firstName', TextType::class)
->add('lastName', TextType::class)
->getForm();