En HTML, la balise <form> spécifie la méthode d'envoi des données :
Astuce
Comment choisir la méthode d'envoi ?
La méthode Get doit être employée lorsque les données ne sont pas trop volumineuses, et surtout lorsque le traitement des données n’a pas d’effet de bord. Dans tous les autres cas, la méthode Post doit être préférée.
La méthode d'envoi Get est celle utilisée par défaut lorqu'on utilise les formulaires sans préciser la méthode :
<form action="traitement.php">
...
</form>
Cette écriture est exactement équivalente à :
<form action="traitement.php" method="get">
...
</form>
Les données du formulaire qui sont passées dans l'URL s'écrivent sous la forme :
http://www.site.com/page.php?param1=valeur1¶m2=valeur2...
Le caractère ? sépare le nom de la page des paramètres.
Chaque couple paramètre/valeur s'écrit sous la forme : nom=valeur; ils sont séparés les uns des autres par le symbole &.
Note
Le nom des paramètres correspond à la valeur de l'attribut @name définit dans chaque balise <input>.
La valeur des paramètres correspond à la valeur de l'attribut @value s'il est définit, ou au texte saisi par l'utilisateur (dans un champ texte par exemple).
Côté serveur (en PHP, donc), les valeurs passées dans l'URL sont stockées dans un tableau associatif $_GET :
Exemple (avec l'URL précédente) :
<?php
$valeur = $_GET[’param1’]; // contient valeur1
?>
Avertissement
Comme les paramètres et leurs valeurs sont intégrés dans l'URL, ils sont directement modifiables.
Il est donc très important de tester si les données reçues sont celles attendues (mauvais type, données manquantes ...).
Lorsque des données transitent par l'URL, il faut s'assurer que les valeurs correspondent au type attentdu. Dans le cas contraire, PHP permet de convertir les valeurs d'un type à un autre.
De plus, il est possible que certains paramètres attendus dans le code PHP soient absents de l'URL, dans ce cas il est possible de tester leur présence avec la fonction isset.
Exemple :
<?php
if (isset($_GET['param1']) AND isset($_GET['param2'])) {
$valeur1 = (int) $_GET['param1'];
$valeur2 = (int) $_GET['param2'];
... // code à exécuter si tous les paramètres sont présents
} else {
...
// code à exécuter par défaut
}
?>
Voir le résultat.
La méthode d'envoi Post doit être spécifiée dans le formulaire si l'on souhaite transmettre des données dans une requête :
<form action="traitement.php" method="post">
...
</form>
Dans ce cas, les paramètres et leurs valeurs envoyés ne seront plus visibles dans l'URL.
Les valeurs transmises par la méthode Post sont stockées dans la variable $_POST. Les données sont stockées de la même manière que dans la variable $_GET.
Avertissement
Même si les paramètres et leurs valeurs sont transmises sans apparaître dans l'URL, il est tout de même possible d'envoyer des valeurs inattendues (par exemple, en modifiant une copie du code HTML du formulaire). Il est d'autant plus important de contrôler les données reçues que les données envoyées en Post peuvent contenir des chaînes de caractères conséquentes (et pourquoi pas, du code HTML ou JavaScript !).
En plus de vérifier le type et la présence des paramètres, le traitement des chaînes de caractères doit comprendre une conversion pour éviter que le texte puisse être interprété comme du code HTML (ou JavaScript).
Il existe des fonctions PHP conçues à cet effet : htmlspecialchars (documentation) et htmlentities (documentation). Elles permettent de convertir les caractères spéciaux en entités HTML. Exemple :
<?php
$value = ( isset($_POST['variable']) ) ?
htmlspecialchars($_POST['variable']) : "";
if((strlen($value) > 0) && (strlen($value) < 50)){
... //
}
?>
Voir le résultat.
Grâce à PHP, il est possible pour l'utilisateur de transmettre un fichier au serveur par l'intermédiaire des formulaires.
Au moment de l'envoi du formulaire (soumission via submit); le fichier est téléchargé par le serveur (on parle d'un "upload" côté client).
Le serveur peut ensuite manipuler le fichier puis l'enregistrer.
Il est possible, dans les formulaires HTML, de définir un champ de type fichier (<input type="file" />) permettant de transmettre des fichiers au serveur.
Le formulaire devra simplement comporter l'attribut d'encodage indiquant l'envoi de fichier(s).
Exemple :
<form action="traitement.php" method="post"
enctype="multipart/form-data">
...
<input type="hidden"
name="MAX_FILE_SIZE" value="1048576" />
<input type="file" name="fichier" />
...
</form>
Note
Du fait du format et du volume des données, l'envoi de fichiers n'est possible qu'en Post.
Le champ <input type="hidden" /> permet de spécifier une taille maximale de fichier.
Les fichiers envoyés depuis un formulaires sont stockées dans une variable différente de $_GET ou $_POST: il s'agit de la variable $_FILES
Les fichiers sont stockés sous la forme d'un tableau à deux dimensions. L'accès fichier par fichier se fait en utilisant la valeur de l'attribut name définit dans le formulaire.
Exemple :
| Variable Signification | Signification |
|---|---|
| $_FILES['fichier']['name'] | Nom du fichier envoyé |
| $_FILES['fichier']['type'] | Type du fichier (ex: image/png) |
| $_FILES['fichier']['size'] | Taille du fichier en octets |
| $_FILES['fichier']['tmp_name'] | Emplacement temporaire du fichier sur le serveur |
| $_FILES['fichier']['error'] | Code d'erreur (0 si pas d'erreur) |
Généralement, côté serveur, le type de fichier attendu ainsi que sa taille limite sont établis à priori. Exemple de script PHP permettant d'effectuer toutes ces vérifications :
<?php
if (isset($_FILES['fichier'])
AND $_FILES['fichier']['error'] == 0
AND $_FILES['fichier']['size'] <= 1048576) { // 1Mo
$infosfichier = pathinfo($_FILES['fichier']['name']);
$ext_upload = $infosfichier['extension'];
$ext_autorisees = array('jpg', 'jpeg', 'gif', 'png');
if (in_array($ext_upload, $ext_autorisees)) {
move_uploaded_file($_FILES['fichier']['tmp_name'],
'destination/' . basename($_FILES['fichier']['name']));
}
}
?>
Note
N'hésitez pas à consulter la documentation PHP pour les fonctions pathinfo() et move_uploaded_file().
Les variables superglobales sont des variables créées et instantiées par PHP.
Parmi les variables superglobales, on retrouve :
Note
Un exemple utile de variable serveur : $SERVER['REMOTE_ADDR'] contient l'adresse IP du client qui cherche à consulter la page.
L'intérêt des sessions est de pouvoir manipuler dans une variable de page en page.
Les variables de type session sont conçues pour garder en mémoire des informations relatives au client.
Fonctionnement des sessions :
Note
La fermeture de la session peut être explicitement demandée où s'exécute automatiquement à la fermeture du navigateur, ou après un délai d'expiration ("timeout").
La variable session $_SESSION est accessible n'importe où dans le code à condition qu'on aie préalablement fait appel à la fonction session_start(). Les variables de session s'instantient comme des champs du tableau associatif $_SESSION. Exemple :
<?php
session_start();
...
$_SESSION['champ1'] = 'Valeur1';
$_SESSION['champ2'] = valeur2;
?>
Avertissement
La fonction session_start() doit être appellée sur chacune des pages avant toute écriture de code HTML.
Toutes les variables de session qui ont prélablement été intitialisées dans des pages consultées par le client sont accessibles sur les autres pages. Il suffit de faire appel à la fonction de démarrage de la session.
Exemple :
<?php
session_start();
...
echo $_SESSION['champ1'];
?>
Astuce
Les variables de session sont utiles en complément d'un système d'authentification, afin de stocker des informations de connexion de l'utilisateur.
La variable $_SESSION est automatiquement détruite après un délai d'expiration, ou à la fermeture du client.
Dans certains cas, il est nécessaire de fermer la session depuis le code (c'est le cas par exemple d'un bouton "Déconnexion" pour des pages à accès restreints).
La fermeture de la session s'effectue comme suit :
<?php
...
session_destroy();
?>
Contrairement aux sessions où les données sont stockées côté serveur, les cookies sont des fichiers qui contiennent des donénes et sont enregistrés côté client.
L'utilité des cookies est de sauvegarder des données relatives au client et dont la portée dépasse celle des sessions.
L'utilisation des cookies se fait en deux temps :
Pour créer un cookie, il suffit d'utiliser la fonction
setcookie($name, $value, $expire, $path, $domain, $secure, $httponly) (voir la documentation) dont les paramètres sont :
Création d'un cookie (qui expire au bout d'une heure):
<?php
setcookie("NomDuCookie",
'valeurDuCookie',
time()+3600,
null,
null,
false,
true );
?>
Avertissement
Le mode "httponly" permet de s'assurer qu'aucun script (JavaScript) ne modifie le cookie.
Note
Pour modifier un cookie existant, il suffit de faire appel à la même fonction, avec un nom de cookie existant.
Les données stockées dans un cookie sont accessibles dans la variable superglobale $_COOKIE qui est un tableau associatif dont les clés correspondent aux noms des cookies enregistrés.
Exemple :
<?php
...
echo $_COOKIE['NomDuCookie'];
?>
Avertissement
Contrairement aux variables de session, les données des variables des cookies peuvent avoir été modifiées par l'utilisateur. Il faut donc leur appliquer un contrôle très strict.
PHP embarque des fonctions très utiles pour ouvrir fopen(), lire fgetc()/fgets() et fermer fclose() un fichier.
Le protocole de lecture est en trois étapes :
Avertissement
Lors de l'ouverture avec fopen(), PHP bloque l'accès au fichier tant que la fonction fclose() n'est pas appellée.
Exemple de lecture ligne par ligne :
<?php
$fichier = fopen('fichier.txt', 'r');
if($fichier != NULL){
$ligne = fgets($fichier);
while($ligne){
... // traitement de la ligne
$ligne = fgets($fichier);
}
fclose($fichier);
}
?>
Note
Le 'r' signifie que le fichier est ouvert en lecture. Voir la documentation pour les autres modes.
Pour écrire dans un fichier, il est utile de savoir modifier le curseur. Il indique la position courante de la lecture/écriture dans le fichier.
Le curseur se déplace avec la fonction fseek() et l'écriture est réalisée par fputs().
La fonction fseek() ne fonctionne qu'avec le mode d'écriture 'r+' ou 'w'. Dans le cas du mode 'a+' (lecture seule + pas d'écrasement), les nouvelles données seront toujours écrites à la fin.
Exemple d'écriture au début du fichier :
<?php
$fichier = fopen('fichier.txt', 'r+');
if($fichier != NULL){
fseek($fichier, 0);
fputs($fichier, 'nouvelles données');
fclose($fichier);
}
?>