Simplifier la gestion des formulaires de manière considérable

Gagnez du temps, réduisez les tâches de maintenance, simplifiez votre code et faites tout cela en vous sentant comme un génie! Dans ce tutoriel, vous apprendrez à utiliser des variables variables, des tableaux de références et un peu de programmation intelligente pour simplifier considérablement la gestion des formulaires..

Variables variables, méthodes et propriétés

Avant de pouvoir utiliser un tableau de recherche trop en profondeur, il est important de comprendre d'abord le concept à la base des variables variables..

Que sont les variables variables??

Variable variable est un terme qui décrit l'utilisation d'une variable pour déclarer une autre variable.

Dans sa forme la plus simple, une variable variable pourrait ressembler à ceci:

 $ foo = 'Une valeur!'; // Déclarer une valeur initiale $ bar = 'foo'; // Attends, qu'est-ce qui se passe? echo $$ bar; // merde! Ce résultat "Une valeur!"

Pourquoi devriez-vous vous en soucier?

Lorsque vous regardez une validation de concept comme dans l'exemple précédent, l'utilisation de variables variables semble probablement assez ridicule et compliquée. Cependant, il existe vraiment de solides raisons pratiques de les utiliser dans certains cas.

Exemples pratiques

L'utilisation responsable de variables variables peut réduire considérablement la quantité de code devant être répétée, par exemple en convertissant un tableau associatif en un objet avec des valeurs assainies..

Exemple sans pour autant variables variables

$ comment = new stdClass (); // Créer un objet $ comment-> name = sanitize_value ($ array ['name']); $ comment-> email = sanitize_values ($ array ['email']); $ comment-> url = sanitize_values ($ array ['url']); $ comment-> comment_text = sanitize_values ($ array ['comment_text']);

Exemple avec variables variables

$ comment = new stdClass (); // Créer un nouvel objet pour chaque objet ($ array en tant que $ key => $ val) $ comment -> $ key = sanitize_values ($ val);

Voyez combien c'était plus simple? Et vous pouvez imaginer ce que l'exemple sans pour autant les variables variables ressembleraient si le tableau avait quelque chose comme 50 ou 100 valeurs.

REMARQUE: Je suis conscient que vous pourriez aussi utiliser array_map () et explicitement convertir le tableau en objet pour accomplir la même chose. Ce n'est pas le propos. Nous illustrons un concept, ici. Jouer en même temps.

Le problème avec le traitement de formulaire

Faire du traitement de formulaire un jeu d'enfant.

Maintenant que vous savez utiliser les variables variables, nous pouvons passer à la viande et aux pommes de terre de cet article, qui est l'idée qu'incorporer un tableau de recherche au lieu de plusieurs fichiers de contrôleur ou une instruction switch peut vous faire économiser beaucoup de maintenance, code répété et maux de tête en général.

Pour illustrer notre concept, nous allons utiliser l'idée de traitement de formulaire. C’est un aspect essentiel de la programmation Web, et peut également être l'un des domaines les plus fastidieux de tout projet.

Cependant, après avoir réévalué vos habitudes de codage, vous pouvez potentiellement simplifier le traitement des formulaires..

Fréquemment, un fichier individuel est créé pour chaque formulaire à traiter ou une instruction switch est utilisée. Dans cette section, nous examinerons comment les deux solutions pourraient être implémentées, puis nous examinerons une solution utilisant des variables variables et comment elle peut améliorer vos projets..

Un exemple de travail avec plusieurs fichiers de traitement de formulaire

Une méthode souvent utilisée pour traiter les soumissions de formulaire consiste à créer un nouveau fichier complet pour gérer les données de chaque formulaire séparément..

Prenez, par exemple, ces trois formulaires qui mettent à jour un compte d'utilisateur avec un nouveau nom, un nouvel email ou les deux:

  Formulaire 1
 prénom     
 
   Formulaire 2
 Email     
 
   Formulaire 3
 prénom   Email

Chacun de ces formulaires pointe vers un fichier de traitement différent. Alors, à quoi ressemble chacun de ces fichiers?

Formulaire de traitement 1 (assets / inc / ex1-form1.php)

save_name (); // Pour cet exemple, il suffit de générer des données sur l'écho d'envoi du formulaire "Fichier de traitement: ", $ _SERVER ['PHP_SELF']," \ n \ nMéthode de sortie:\ n ", $ output,"
\ n ", 'Retourner
';  else die ('Soumission de formulaire invalide');

Formulaire de traitement 2 (assets / inc / ex1-form2.php)

save_email (); // Pour cet exemple, il suffit de générer des données sur l'écho d'envoi du formulaire "Fichier de traitement: ", $ _SERVER ['PHP_SELF']," \ n \ nMéthode de sortie:\ n ", $ output,"
\ n ", 'Retourner
';  else die ('Soumission de formulaire invalide');

Formulaire de traitement 3 (assets / inc / ex1-form3.php)

save_both (); // Pour cet exemple, il suffit de générer des données sur l'écho d'envoi du formulaire "Fichier de traitement: ", $ _SERVER ['PHP_SELF']," \ n \ nMéthode de sortie:\ n ", $ output,"
\ n ", 'Retourner
';  else die ('Soumission de formulaire invalide');

Comme vous pouvez le constater, les exemples de fichiers ci-dessus dupliquent une tonne de code. Étendez-le à 15 formulaires sur un site et vous constaterez rapidement que la maintenance peut devenir un cauchemar..

La classe de compte

Comme vous pouvez le constater, les fichiers de traitement créent une instance de la classe. CopterLabs_Account. Ce sera une classe très simple qui sort des informations sur une soumission de formulaire.

Voici le code de la classe (assets / inc / class.coperlabs_account.inc.php):

 * @copyright 2011 Copter Labs * @license http://www.opensource.org/licenses/mit-license.html * @license http://www.gnu.org/licenses/gpl-3.0.txt * / class CopterLabs_Account public $ name = NULL, $ email = NULL; fonction publique save_name () $ this-> name = htmlentities ($ _ POST ['name'], ENT_QUOTES); retourne "Méthode:". __MÉTHODE__ . "\ nNom:". $ this-> name. "\ n";  fonction publique save_email () $ this-> email = htmlentities ($ _ POST ['email'], ENT_QUOTES); retourne "Méthode:". __MÉTHODE__ . "\ nEmail:". $ this-> email. "\ n";  fonction publique save_both () $ this-> name = htmlentities ($ _ POST ['name'], ENT_QUOTES); $ this-> email = htmlentities ($ _ POST ['email'], ENT_QUOTES); retourne "Méthode:". __MÉTHODE__ . "\ nNom:". $ this-> name. "\ nEmail:". $ this-> email. "\ n";

Vous pouvez essayer ce code à l'exemple 1 sur la page de démonstration.

Exemple de travail avec un fichier de traitement unique et une instruction switch

Une autre solution populaire pour le traitement de formulaire consiste à consolider tous les scripts de traitement dans un seul fichier et à déterminer quoi faire avec les données à l'aide d'une instruction switch.

L'approche de commutation utilise généralement une astuce dans laquelle une entrée masquée est ajoutée au formulaire contenant une action à exécuter lors de la soumission. Ce
l'action est ensuite utilisée pour déterminer quoi faire avec le formulaire.

Voici les trois mêmes formulaires, en haut, avec les actions ajoutées, tous pointant vers un seul fichier de traitement:

  Formulaire 1
 prénom      
 
   Formulaire 2
 Email      
 
   Formulaire 3
 prénom   Email

Et le nouveau fichier de traitement ressemble à ceci: (assets / inc / ex2-switch.php)

save_name (); Pause; // Formulaire 2, cas de traitement 'update-email': $ output = $ account_obj-> save_email (); Pause; // Formulaire 3, cas de traitement 'update-both': $ output = $ account_obj-> save_both (); Pause; // Si aucune action valide n'est trouvée, quelque chose ne va pas. Default: die ('Action non supportée.');  // Pour cet exemple, il suffit de générer des données sur l'écho d'envoi du formulaire "Fichier de traitement: ", $ _SERVER ['PHP_SELF']," \ nAction: ", htmlentities ($ _ POST ['action'], ENT_QUOTES)," \ n \ nMéthode de sortie:\ n ", $ output,"
\ n ", 'Retourner à l'exemple 2
';  else die ('Soumission de formulaire invalide');

Vous pouvez le voir en action en consultant Exemple 2 sur la page de démonstration. Il s'agit d'une nette amélioration par rapport à l'utilisation de plusieurs formulaires, mais vous pouvez voir que nous dupliquons encore du code..

En plus de cela, ma préférence personnelle est d'éviter commutateur déclarations chaque fois que je peux. Ceci est dû au fait que commutateur utilise des comparaisons lâches ('un string' va déclencher cas 0 parce qu'une chaîne est évaluée à 0 si vous le convertissez en un entier) et est extrêmement facile à transformer en code spaghetti.

Résoudre le problème: Tableaux de recherche et variables variables

Comme nous l'avons vu jusqu'à présent, les deux solutions ci-dessus ont leurs inconvénients et nécessitent un code en double. Imaginez s’il y avait une douzaine ou plus de formulaires sur le site - ce n’était pas beau.

Pour résoudre ce problème, nous pouvons utiliser un concept appelé tableau de recherche, qui mappe les actions passées du formulaire à une méthode appelée sur l'objet.

Oui, vous pouvez définir l'action comme nom de méthode, mais cela permet à une soumission de formulaire fictive d'appeler n'importe quelle méthode publique. Faire du tableau une paire clé-valeur est une petite étape pour ajouter un peu plus de contrôle sans trop de travail supplémentaire.

Un exemple de travail avec un fichier de traitement unique et un tableau de recherche

En utilisant notre connaissance des variables variables depuis le début de ce tutoriel, modifions notre démonstration pour utiliser un tableau de recherche..

Modifiez les trois formulaires pour qu'ils pointent vers un nouveau fichier de contrôleur:

  Formulaire 1
 prénom      
 
   Formulaire 2
 Email      
 
   Formulaire 3
 prénom   Email

Ensuite, rassemblez le fichier de traitement qui gérera les soumissions de formulaires (assets / inc / ex3-lookup-array.php):

 'save_name', 'update-email' => 'save_email', 'update-both' => 'save_both'); // Assurez-vous que la clé de tableau existe si (array_key_exists ($ action, $ lookup_array)) // à l'aide de variables variables, appelez la méthode appropriée et stockez la sortie $ output = $ account_obj -> $ lookup_array [$ action] ();  else die ('Action non supportée.');  // Pour cet exemple, il suffit de générer des données sur l'écho d'envoi du formulaire "Fichier de traitement: ", $ _SERVER ['PHP_SELF']," \ nAction: ", htmlentities ($ _ POST ['action'], ENT_QUOTES)," \ n \ nMéthode de sortie:\ n ", $ output,"
\ n ", 'Retourner à l'exemple 3
';  else die ('Soumission de formulaire invalide');

Vérifiez ceci sur la page de démonstration en essayant les formulaires de l'exemple 3.

Puisque nous définissons l'action comme clé dans le tableau, nous utilisons array_key_exists () pour s'assurer que l'action est valide. Ensuite, nous utilisons la valeur qui correspond à l'action en tant que nom de méthode. Notez que nous avons ajouté les parenthèses après la valeur pour nous assurer qu’elle est exécutée en tant que méthode..

L'ajout du tableau de recherche garde le code concis, simple et clair (une fois que vous avez saisi les variables variables).

Résumé

Utilisés de manière responsable, les tableaux de recherche peuvent faciliter la mise à jour et la maintenance de vos scripts lorsque vous les combinez avec des variables variables..

Comment pensez-vous pouvoir intégrer des tableaux de recherche et des variables variables dans vos projets pour faciliter la maintenance? Faites-moi savoir dans les commentaires!

Code