En général, pour chaque formulaire sur un site on créé une fonction spécifique. Ce qui peut s’avérer rapidement une grosse perte de temps.

La problématique est donc posée : comment gagner du temps tout en effectuant des contrôles sur les formulaires en bonne et due forme ?

Il suffit d’avoir une seule et même fonction pour l’ensemble des formulaires. C’est là que l’utilisation de jQuery devient très intéressante. En effet, avec jQuery il est possible d’agir sur les éléments de la page ayant le même sélecteur.

Nous allons donc définir une classe spécifique aux éléments de formulaire obligatoires. De plus, nous allons indiquer un élément title aux champs formulaires afin de pouvoir les réutiliser dans notre fonction :

<input name="nom" id="nom" class="obligatoire" title="Nom" type="text">

Ainsi, tous les éléments ayant la classe « obligatoire » devront être remplis. La fonction javascript suivante se charge du contrôle :

function VerifForm(){
var count=1;
var message="";
$(".obligatoire").map(function(){

if($(this).val()== »)
{
message += « \n – « +$(this).attr(« title »);
count++;
}
});

message += « \n\n »+ »Puis validez de nouveau le formulaire »;

if(count==2) { alert(« Veuillez remplir ce champ :\n »+message);
return false; }
else if(count>2) { alert(« Veuillez remplir ces champs\n »+message);
return false; }
else { return true; }

}

Ainsi, si le champ « nom » n’est pas rempli, une alerte javascript (qui peut être modifiée par une alerte ajax, avec par exemple le plugin facebox) indiquera que le champ n’est pas rempli.

Il ne faut pas oublier d’appeler cette fonction dans la balise <form> : onsubmit= »return VerifForm(); »

Cette fonction est basique et doit être améliorée pour prendre en compte d’autres éléments de formulaire tels que les cases checkbox, les boutons radio, etc. De plus, il serait judicieux de définir des classes différentes pour contrôler les adresses email, les numéros de téléphone, etc.

Pour inaugurer cette partie, je vous fournis 4 fonctions (+ 2 variantes) bien utiles pour faire des traitements SQL de base à savoir : SELECT, INSERT, UPDATE et DELETE.

Ces fonctions sont finalement assez simples, mais ça fait gagner du temps. De plus, ce genre de fonction permet d’opérer des changements sur toutes les requêtes identiques très simplement (ex : en cas de changement de système de base de données).

Insérer un enregistrement :

function inserer_sql($table,$champs,$donnees)
{
$sql = "INSERT INTO $table ($champs) ";
$sql .= "VALUES ($donnees)";

if(mysql_query($sql))
{
return true;
}
else
{
return false;
}
}

Et pour l’utiliser, c’est tout aussi simple. Par exemple :

if(inserer_sql("utilisateurs","email,nom,prenom",
"'$_POST[email]','$_POST[nom]','$_POST[prenom]'"))
echo"L'ajout a été effectué avec succès";
else echo"L'ajout a échoué";

Ensuite, pour gagner du temps j’utilise une autre fonction qui n’a comme arguments que le nom de la table et la liste des champs à ajouter (sous forme de tableau). Cela suppose bien sur une correspondance des champs du formulaire (données POST) et des champs de la table :

function inserer_sql_array($table,$array)
{
$req="";
$i=1;
foreach($array as $k)
{

if($i!=’1′) { $req.= », « ; $req2.= », « ; }

$req.= »$k »;
$req2.= »‘$_POST[$k]‘ »;
$i++;
}

return inserer_sql($table,$req,$req2);
}

Il suffit de l’utiliser comme ceci :

if(inserer_sql_array("utilisateurs",array("email,nom,prenom"))
echo"L'ajout a été effectué avec succès";
else echo"L'ajout a échoué";

Modification de données :

Sur le même principe que pour l’ajout j’ai cette fonction :

function maj_sql($table,$action,$where)
{
if($where=='') { $where=1; }

$sql = « UPDATE $table SET $action « ;
$sql .= « WHERE $where »;

if(mysql_query($sql))
{
return true;
}
else
{
return false;
}
}

Dans cette fonction, il est permis de modifier tous les enregistrements d’une table (en laissant l’argument $where à vide). Mais, par mesure de sécurité, on peut désactiver cela en testant la variable $where au début et en renvoyant false si elle est vide.

Pour utiliser cette fonction, il suffit de tester que la fonction renvoie bien true.

La variante de cette fonction qui génère la requête à partir d’un tableau array() :

function maj_sql_array($table,$array,$where)
{
$req="";
$i=1;
foreach($array as $k)
{
if($i!='1') $req.=", ";

$req.= »$k=’$_POST[$k]‘ »;
$i++;
}

maj_sql($table,$req,$where);
}

Suppression de données :

Cette fonction permet de supprimer un ou plusieurs enregistrements dans une table en précisant uniquement la table et la condition à remplir. Cependant, par mesure de sécurité, il est impossible de ne pas préciser de condition (cela supprimerait tous les enregistrements de la table) :

function sup_sql($table,$where)
{

if($where== ») {
return false;
}
else
{
$sql = « DELETE FROM $table « ;
$sql .= « WHERE $where »;

if(mysql_query($sql))
{
return true;
}
else
{
return false;
}
}
}

Lire une ligne d’une table :

Enfin, la dernière fonction permet d’extraire les données d’un enregistrement d’une table. C’est bien sûr en fait un simple SELECT mais comme pour les autres fonctions, cela permet de gagner du temps.

function requete_sql($table,$champs,$where)
{
// si $where est vide on lui attribue une valeur par défaut
if($where=='') { $where=1; }

// en cas de jointure on utilise le nom de la première table pour le tri par ID.
$tab=explode(« , »,$table);

$sql = « select $champs from $table where $where ORDER by $tab[0].id DESC LIMIT 1″;
$p = mysql_query($sql)OR DIE(« Erreur sur la requete SELECT $champs FROM $table WHERE $where »);
return mysql_fetch_array($p);
}

Le résultat de cette fonction est un tableau contenant les données précisées dans l’argument $champs. Exemple :

$requete=requete_sql("utilisateurs","nom,prenom,email","id='$_GET[user]'");
echo"Bonjour ".$requete[prenom]." !";

En bonus, voici la fonction qui permet de compter le nombre d’enregistrements dans une table pour une condition précise. Cette fonction effectue un mysql_numrows sur une requête SELECT. Les puristes préféreraient sans doûte un SELECT count(id), cependant, il me semble que ma méthode est moins lourde :

function compter_sql($table,$where)
{
if($where=='') { $where=1; }
$sql = "select id from $table where $where";
$p = mysql_query($sql)OR DIE("Erreur sur la requete SELECT id FROM $table WHERE $where");
return mysql_numrows($p);
}

Cette fonction suppose que vous avez une colonne id dans votre table puisque le SELECT est effectué dessus. Pour l’utiliser, rien de plus simple :

$nb_utilisateurs_hommes = compter_sql("utilisateurs","sexe='H'");

Conclusion :

Ces petites fonctions ne sont pas révolutionnaires en soit puisqu’elles reprennent les principes de base de SQL. Cependant, et ce n’est pas négligeable, elles permettent réellement de gagner du temps car elles sont plus rapides à écrire et plus faciles à retenir (je retiens mieux des noms de fonction en français qu’en anglais).

Bien sûr, elles ne sont pas parfaites, il faudrait protéger les données à insérer ou à modifier par des htmlspecialchars() et addslashes(). Mais pour ça, c’est à vous de jouer, je ne vais pas vous prémacher tout le travail non plus !

• Bien penser la structure de sa base de données avant le développement afin de réduire au maximum le nombre de requêtes SQL dans le développement (par exemple, ne pas hésiter à créer une colonne contenant le nombre de messages postés par un utilisateur – qui sera remis à jour à chaque message qu’il postera – plutôt que de faire un mysql_num_rows à chaque affichage de ce nombre).

• Mettre en cache tout ou une partie du contenu (stocker la page dans un fichier html et l’afficher s’il existe ou sinon affichage de la page php et génération du cache).

• Mettre en cache des variables avec les fonctions serialize et unserialize. Cela permet par exemple de mettre en cache le résultat d’un mysql_fetch_array assez lourd appelé sur chaque page (comme des variables sur l’utilisateur ou le contenu de menus…). J’y reviendrais plus en détail dans un prochain billet.

• Optimiser les requêtes SQL : utiliser les jointures (SELECT sur plusieurs table ayant des champs en communs) et ne pas faire de SELECT * (select sur tous les champs) mais lister les champs utilisés (SELECT id,login,nom FROM …).

• Mettre des index intelligents sur les tables SQL. Les index permettent un gain de temps d’accès énorme. Il faut les placer sur les colonnes utilisées dans la clause WHERE.

• Compresser vos pages web, fichiers CSS et javascripts à l’aide de la fonction gzip de php. Vous trouverez sur ce site une classe complète pour compresser vos pages. Cela peut paraître idiot à l’heure du haut débit : il faut optimiser le poids des images car des images lourdes ralentissent malgré tout le chargement de la page.

• Vérifier qu’un script, notamment de régie publicitaire, ne ralentit pas l’affichage de la page. Cela arrive fréquemment et certaines régies sont championnes dans ce domaine !

N’hésitez pas à compléter si j’ai oublié des choses