Une application (Internet ou autre), doit souvent exécuter le même code à plusieurs endroits du programme, ou dans différents programmes. Un exemple pourrait être par exemple l'affichage d'un logo dans toutes vos pages web :
Exemple 22. Affichage d'un logo en PHP
echo '<p><hr width="50" align="left" />',"\n"; echo '<img src="/images/logo.jpg" width="50" height="50" alt="logo" /><br />',"\n"; echo '<hr width="50" align="left" /></p>',"\n";
Un fonction affiche_logo pourrait reprendre toutes les instructions précédentes. L'affichage du logo se ferait alors par simple appel à cette fonction :
Cette notion de fonction a plusieurs avantage :
moins de code à écrire
une meilleure lisibilité
moins d'erreurs au développement
une meilleure évolutivité
La déclaration d'une fonction se fait de la manière suivante :
function nom_fonction()
{
bloc d'instructions;
return;
}
Ce qui donnerait pour l'exemple précédent la déclaration suivante :
Exemple 24. Fonction d'affichage d'un logo en PHP
function affiche_logo()
{
echo '<p><hr width="50" align="left" />',"\n";
echo '<img src="/images/logo.jpg" width="50" height="50" alt="logo" /><br />',"\n";
echo '<hr width="50" align="left" /></p>',"\n";
return;
}
Le mot clef return interrompt l'exécution de la fonction, et provoque le retour au programme appelant. Toute fonction devrait comporter au moins une instruction return.
Il est également possible de manipuler des variables dans les fonctions, et nous distinguerons alors les variables locales (celles qui ne sont visibles qu'à l'intérieur du corps de la fonction), et les paramètres de la fonction, variables qui sont affectées lors de l'appel à la fonction.
La déclaration d'une variable dans le corps d'une fonction a la particularité de ne la rendre visible que dans la fonction. On parle alors de portée de variable, limitée à une portée locale dans ce cas. L'exemple suivant ne produit pas de sortie :
Exemple 25. Fonction d'affichage d'un logo en PHP
//déclaration de la fonction
function format_nom()
{
$prenom = "Ivan"; //déclaration de la variable en local
$nom = "Kurzweg";
$nom_complet = $prenom.", ".$nom; //pas d'erreurs à l'exécution
}
//appel de la fonction dans la page PHP
format_name();
//mais aucune sortie à l'exécution de echo, la variable name n'est pas connue
echo "$name";
Il existe la possibilité d'augmenter la portée d'une variable à toute la page PHP en utilisant le mot clef global. Mais cette technique est souvent source d'erreurs et de confusion, nous ne nous y attarderons pas.
Il est possible de passer des valeurs entre une fonction et le programme appelant, et ce dans les deux sens : du programme appelant vers la fonction en utilisant les paramètres de la fonction, et de la fonction vers le programme appelant en utilisant l'instruction return.
Pour passer des paramètres (des valeurs) à une fonction, il faut au préalable avoir déclaré la fonction de manière à ce qu'elle attende ces valeurs :
function nom_fonction($var1, $var2, ...)
{
bloc d'instructions;
return;
}
L'appel de la fonction se fait alors en renseignant les valeurs :
nom_fonction(valeur,valeur,...);
Exemple 26. Fonction de calcul d'un montant TTC
//déclaration de la fonction
function calul_ttc($montantHT,$tva)
{
switch ( $tva )
{
case "HT" :
$taxes = 0;
break;
case "DOM" :
$taxes = 1.086;
break;
default:
$taxes = 1.186;
break;
}
$montantTTC = $montantHT * $taxes;
echo "$=montantTTC<br>";
}
//initialisation des variables
$prix = 2000.00;
$tauxTaxes = "DOM";
//appel de la fonction
calcul_ttc($prix,$tauxTaxes);
S'il est possible de passer des valeurs en paramètres à une fonction, il est également possible d'obtenir une valeur de la fonction. C'est le rôle de l'instruction return de renvoyer la valeur selon le modèle suivant :
function nom_fonction($var1, $var2, ...)
{
bloc d'instructions;
return valeur;
}
Il est alors possible d'affecter la valeur de retour de la fonction à une variable du programme appelant :
$variable = nom_fonction(valeur,valeur,...);
Exemple 27. Fonction de calcul d'un montant TTC
//déclaration de la fonction
function calul_ttc($montantHT,$tva)
{
switch ( $tva )
{
case "HT" :
$taxes = 0;
break;
case "DOM" :
$taxes = 1.086;
break;
default:
$taxes = 1.186;
break;
}
$montantTTC = $montantHT * $taxes;
//on ne fait plus l'echo, mais on va renvoyer la valeur obtenue
//echo "$=montantTTC<br>";
return $montantTTC;
}
//initialisation des variables
$prix = 2000.00;
$tauxTaxes = "DOM";
//appel de la fonction, et affectation du résultat à une variable
$montant = calcul_ttc($prix,$tauxTaxes);
Il existe un certains nombres de fonctions intégrées au langage PHP, ou accessibles après l'ajout d'un module complémentaire. Nous avons par exemple vu des fonctions propres à MySQL, disponibles puisque nous avons installé le paquet PHP5-mysql.
Ainsi, nous pouvons disposer de fonctions prédéfinies, qui permettent par exemple de manipuler des images, de générer des fichiers au format PDF, etc.. Le site www.php.net vous en présente de nombreuses.
Php permet de stocker des instructions dans des fichiers externes - un fichier séparé du programme - et l'ajouter dans toutes les pages nécessaires. L'instruction include permet de réaliser cette "importation". Cette méthode se révèle pratique pour stocker des instructions, des fonctions ou des variables utilisées fréquemment. Le format d'une inclusion est le suivant :
include("chemin/nom_fichier");
Le fichier peut avoir n'importe quel nom, mais vous pouvez par exemple le suffixer de .inc. Si le fichier contient du code PHP, ne pas oublier les caractères signalant le début et la fin de ce code ..
De manière à rendre l'application Internet que vous développez facilement maintenable et lisible, voici la liste d'un certain nombre de données à inclure dans des fichiers séparés, appelés depuis les pages PHP :
Du code HTML : il peut être intéressant de mettre beaucoup de code HTML dans des fichiers d'inclusion. Par exemple, la partie déclarative (doctype et entête de la page), les parties du code HTML fixes sur le site (bandeau de navigation, pied de page, etc ..), voir même des fomulaires .. De manière générale, il faut essayer de mettre toutes les parties de codes HTML répétitives dans es fichiers à inclure ...
Les informations nécessaires pour accèder à la base de données. En effet, lors de la migration du site depuis l'environnement de développement vers l'environnement de production, il n'y aura que ce fichier à modifier :
<? $host = "localhost"; $user = "init_ll"; $password = "pass_initll"; if (!$connexion = mysql_connect($host,$user,$password)) { $message = mysql_error(); echo "$message<br>"; die(); } ?>Les fonctions PHP : nous avons vu dans les paragraphes précédents la manière de concevoir des fonctions. Il peut être intéressant de les mutualiser dans des fichiers d'inclusion.
Au final, une page PHP qui fournira une page HTML complète pourrait s'écrire :
Exemple 28. Inclusion de fichiers HTML et PHP
<?
//------------------------------------------------------------------
// inclusions des entêtes et des codes PHP
//-----------------------------------------------------------------
//inclusion des entêtes HTML
include("entete.inc");
//inclusion des fonctions PHP
include("fonctions.inc");
//inclusion du bandeau de navigation
include("bandeau.inc");
//inclusion de la connexion à la base
include("connect.inc");
?>
<?
//-----------------------------------------------------------------------
//traitements PHP et affichage du corps de la page
//des requêtes SQL, du code HTML , etc
//----------------------------------------------------------------------
...
...
...
?>
<?
//----------------------------------------------------------------------
// inclusions des codes HTML de base de page
//----------------------------------------------------------------------
//inclusion des pieds de page HTML
include("pied_page.inc");
?>
On parle de session comme du temps passé par un utilisateur sur l'application développée. Durant cette session, il peut être nécessaire de stocker des informations de bout en bout, comme le numéro de l'utilisateur par exemple. Php propose ainsi les variables de session, attribuée à chaque utilisateur pour sa session.
Pour permettre de distinguer les utilisateurs entre eux, PHP assigne un identifiant de session, unique. Ce numéro est stocké sur le serveur, dans un fichier, et chez le client soit via des cookies, soit de page en page en utilisant la méthode POST si les cookies sont désactivés. Les variables de session sont obtenues en utilisant le tableau $_SESSION.
Les sessions doivent être démarrées depuis les pages PHP, en utilisant la fonction session_start. L'exemple suivant propose deux pages utilisant des variables de session :
Exemple 29. Démarrer une session
<?
session_start();
?>
<html>
<head><title>Premiere page</title></head>
<body>
<?
$_SESSION['var_session'] = "testing";
?>
<p>Un test ...
<form action="sessionTest2.php" method="POST">
<input type="hidden' name="var_form" value="testing" />
<input type="submit" value="Page suivante" />
</form>
</p>
</body></html>
Exemple 30. Récupérer la variable de session
<?
session_start();
?>
<html>
<head><title>Seconde page</title></head>
<body>
<?php
echo "variable_session = {$_SESSION["var_session"]}<br />\n";
echo "var_form = {$_POST["var_form"]}<br />\n";
?>
</body></html>
La sécurité a été longtemps quelque peu ignorée par les développeurs, mais un "défaçage" n'arrive pas qu'aux autres ! Les risques principaux d'une mauvaise sécurisation sont :
Vol d'information : revente des adresses mails stockées, réutilisation des numéros de cartes bleues, etc ...
Défaçage : effacement complet du site et de la base de données
Fishing : utilisation de votre site à des fins frauduleuses
...
S'il n'est pas possible de donner la liste exhaustives des risques, des attaques et des moyens de défense, voici quelques items minimums sur lesquels s'attarder :
Ne pas laisser des répertoires en accés direct : quand une url pointe vers un répertoire pluôt qu'un fichier - http://www.kurweg.info/InitLL2007/, le serveur renvoie automatiquement la page
index.html, index.htmouindex.php. Si cette page n'est pas présente dans le répertoire, le serveur peut alors lister tous les fichiers du répertoires, sauf si l'option Indexes est en place. A ce moment là, le serveur refuse le listage du répertoire.Sécuriser les mots de passe : nous avons vu qu'il était envisageable de stocker les informations de connexion à la base de données dans un fichier include. Bien évidemment, il faudra protéger ce fichier (utiliser les fichiers
.htpasswd).Sécuriser les formulaires : même si PHP propose maintenant d'office des mécanisme de protection contre les injections de codes, il peut être judicieux de bien vérifier l'emploi des données entrées dans les formulaires.