Les formulaires

1. Le modèle

Dans leur utilisation la plus fréquente, les formulaires permettent d’interagir avec la couche Modèle (bien que le composant puisse fonctionner avec des tableaux). Les « cibles » des formulaires sont donc des objets.

Imaginons une classe représentant un client :

<?php 
namespace App\Model;  
  
class Client  
{  
   private $nom;  
   private $dateDeNaissance;  
  
   public function setNom($nom)  ...

1. L’objet « Form »

L’objet Form est le principal élément utilisé au niveau du contrôleur. Dans l’exemple ci-dessus, il est contenu dans la variable $form. Il représente l’ensemble des champs du formulaire, sous forme hiérarchique.

C’est le point central autour duquel tout s’articule. L’objet représentant la requête HTTP ou l’objet de la couche Modèle y est « injecté ». Les tâches de traitement classiques (telles que la gestion de la soumission, la validation ou la création de la vue du formulaire) se font également au travers de cet objet Form.

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

1. L’héritage

Avant d’aborder les différents types ainsi que leurs options, il est nécessaire de comprendre l’héritage de ceux-ci.

Chaque type peut hériter d’un parent. En pratique, la quasi-totalité des types utilisés avec Symfony héritent du même type : FormType. Nous avons déjà utilisé ce type indirectement : le « nœud » principal de la hiérarchie du formulaire est par défaut de type FormType.

2. FormType

C’est un type plutôt abstrait, contenant des options de configuration assez générales. La plupart du temps, nous ne l’utilisons pas directement, mais au travers de ses nombreux sous-types.

$formBuilder->add('champ', TextType::class...

1. Définir un formulaire avec la classe AbstractType

Pour ce faire, nous devons créer une classe implémentant l’interface Symfony\Component\Form\FormTypeInterface. Pour simplifier cette tâche, nous pouvons nous servir de la classe Symfony\Component\Form\AbstractType. Cette classe contient différentes méthodes liées à la configuration d’un formulaire.

En réalité, et comme nous l’avons vu précédemment, ce que nous entendons par « formulaire » est simplement le nœud principal d’une certaine arborescence. À ce titre, la principale différence entre un formulaire permettant la modification d’informations sur un client et un champ de type text est que le premier est un nœud avec des enfants, tandis que le second est un nœud simple. C’est pour cette raison que pour configurer un formulaire au sein d’une classe, nous définissons un type.

Cela peut prêter à confusion mais il est très important de comprendre le point précédent, car de celui-ci découlent deux utilisations distinctes de la classe AbstractType :

L’exemple suivant contient la configuration d’un formulaire relatif aux coordonnées d’un client :

<?php 
  
namespace App\Form\Type;  
  
use Symfony\Component\Form\AbstractType;  
use Symfony\Component\Form\FormBuilderInterface;  ...

1. Objectifs

Avec Symfony, la validation est un composant pouvant être utilisé de manière autonome. Cependant, en pratique, il est principalement utilisé pour la validation de données en provenance de formulaires. C’est pour cette raison que nous l’abordons au sein de ce chapitre.

Nous entendons ici la validation « côté serveur ». Il est important de ne pas la confondre avec la validation côté client en HTML5.

Les options telles que required, ou le fait d’utiliser un champ de type email, donneront lieu à une validation au niveau du navigateur, mais celle-ci ne doit en aucun cas être considérée comme fiable. C’est seulement un complément à la validation côté serveur car cela permet de réduire les interactions avec le serveur en détectant des erreurs avant la soumission.

2. La définition des contraintes de validation

Les contraintes de validation sont un ensemble de règles pouvant être appliquées à une valeur. Ces règles permettent de s’assurer que la valeur correspond à un ou plusieurs critères donnés.

Concrètement, pour un formulaire d’inscription par exemple, ces règles pourraient être les suivantes :

Il existe deux méthodes pour configurer les contraintes d’un formulaire :

Configurons la validation d’un formulaire d’envoi d’e-mails avec les deux méthodes. Le formulaire est constitué avec les champs et règles suivants :

1. Afficher le formulaire manuellement

Pour l’instant, nous avons utilisé la méthode Twig form() sur l’objet FormView pour afficher un formulaire :

{{ form(form) }} 

Cette simple fonction permet l’affichage du formulaire entier. Elle est donc très pratique mais est aussi très restrictive. En effet, elle n’offre aucune possibilité de contrôle sur le rendu final.

Le morceau de code suivant est équivalent à la fonction form() :

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

Il introduit de nouvelles fonctions Twig liées à l’affichage de formulaires : form_start(), form_label(), form_errors(), form_widget() et form_end().

$form = $this->createForm(new RechercheType(), null, array( 
    'action' => $this->generateUrl('recherche'), 
    'method' => 'GET', ...