Formularios

1. El modelo

En su uso más común, los formularios permiten interactuar con la capa Modelo (aunque el componente puede trabajar con tablas). Por lo tanto, los «objetivos» de los formularios son objetos.

Imagine una clase que representa a un cliente:

<?php  
namespace App\Model;   
   
class Cliente   
{   
   private $nombre;   
   private $fechaDeNacimiento;   
   
   public function setNombre($nombre)   
   {   
       $this->nombre...

1. El objeto «Form»

El objeto Form es el elemento principal utilizado a nivel de controlador. En el ejemplo anterior, está contenido en la variable $form. Representa el conjunto de campos del formulario en forma jerárquica.

Este es el punto central alrededor del que gira todo. El objeto que representa la consulta HTTP o el objeto de la capa Modelo, se «inyecta» en él. Las tareas de procesamiento típicas (como administrar el envío, validar o crear la vista de formulario) también se realizan a través de este objeto Form.

if ($request->isMethod('POST')) {  
    $form->submit($request);  
} 

1. Herencia

Antes de abordar los diferentes tipos y sus opciones, es necesario entender la herencia de estos.

Cada tipo puede heredar de un padre. En la práctica, casi todos los tipos utilizados con Symfony heredan del mismo tipo: FormType. Ya hemos usado este tipo indirectamente: por defecto, el «nodo» principal de la jerarquía del formulario es de tipo FormType.

2. FormType

Este es un tipo bastante abstracto, que contiene opciones de configuración generales. La mayoría de las veces no lo usamos directamente, sino a través de sus muchos subtipos.

$formBuilder->add('campo', TextType::class, array(  
    'data' => 'Valor por defecto'  
)); 

1. Definir un formulario con la clase AbstractType

Para ello, necesitamos crear una clase que implemente la interfaz Symfony\Component\Form\FormTypeInterface. Para simplificar esta tarea, podemos usar la clase Symfony\Component\Form\AbstractType. Esta clase contiene varios métodos relacionados con la configuración de un formulario.

En realidad, y como hemos visto anteriormente, lo que entendemos por «formulario» simplemente es el nodo principal de una determinada arborescencia. A este respecto, la principal diferencia entre un formulario que permite modificar información sobre un cliente y un campo de tipo text es que el primero es un nodo con hijos, mientras que el segundo es un nodo simple. Por esta razón, para configurar un formulario dentro de una clase, definimos un tipo.

Esto puede resultar confuso, pero es muy importante entender el punto anterior porque tiene dos usos distintos para la clase AbstractType:

El siguiente ejemplo contiene la configuración de un formulario para la información de contacto de un cliente:

<?php  
// src/Form/Type/ClienteType.php   
   
namespace App\Form\Type;   
   
use Symfony\Component\Form\AbstractType;   
use Symfony\Component\Form\FormBuilderInterface;   
use Symfony\Component\OptionsResolver\OptionsResolver;   
   
class ClienteType extends AbstractType   
{   
   public function buildForm(   
       FormBuilderInterface $builder,   
       array...

1. Objetivos

Con Symfony, la validación es un componente que se puede utilizar de forma autónoma. Sin embargo, en la práctica, se usa principalmente para validar datos que provienen de formularios. Por esta razón lo abordamos en este capítulo.

Aquí nos referimos a la validación «en el lado del servidor». Es importante no confundirlo con la validación en el lado del cliente en HTML5.

Las opciones como required, o el hecho de utilizar un campo de tipo email, provocarán una validación a nivel del navegador, pero esto no se debe considerar fiable de ninguna manera. Es solo un complemento de la validación en el lado del servidor, ya que reduce las interacciones con el servidor al detectar errores antes del envío.

2. Definir restricciones de validación

Las restricciones de validación son un conjunto de reglas que se pueden aplicar a un valor. Estas reglas permiten garantizar que el valor se corresponda con uno o más criterios dados.

Concretamente, para un formulario de inscripción, por ejemplo, estas reglas podrían ser las siguientes:

Hay dos métodos para configurar las restricciones de un formulario:

Configuremos la validación de un formulario de correo electrónico con ambos métodos. El formulario consta de los siguientes campos y reglas:

...  
use Symfony\Component\HttpFoundation\Request;   
use Symfony\Component\Form\Extension\Core\Type\EmailType;   
use Symfony\Component\Form\Extension\Core\Type\TextType;   
use Symfony\Component\Form\Extension\Core\Type\FileType;   
use Symfony\Component\Form\Extension\Core\Type\SubmitTyp   ...

1. Ver el formulario manualmente

Por ahora, usamos el método Twig form() en el objeto FormView para mostrar un formulario:

{{ form(form) }} 

Esta sencilla función permite la visualización del formulario completo. Por lo tanto, es muy práctica, pero también muy restrictiva. De hecho, no ofrece ninguna posibilidad de control sobre la representación final.

El siguiente fragmento de código es equivalente a la función form():

{{ form_start(form) }}   
   
   {{ form_label(form) }}   
  
   {{ form_errors(form) }}   
   
   {{ form_widget(form) }}   
   
{{ form_end(form) }} 

Introduce nuevas funciones Twig relacionadas con la visualización de formularios: form_start(), form_label(), form_errors(), form_widget() y form_end(). 

$form = $this->createForm(new BusquedaType(), null, array(  
    'action' => $this->generateUrl('buscar'),  
    'method' => 'GET',  
));