Code-Web.org - html

Des formulaires accessibles

Thierry Geindre — Tue, 11 Mar 2008 16:54:00 +0000

Votre site passe au validateur du W3C? Parfait vous avez respecté une norme à la lettre en développant votre site et on ne peut que vous en féliciter. Pourquoi ne pas jeter un petit coup d'œil à vos formulaires en vous appuyant sur les quelques conseils que je vous donne dans cet article. Vous y trouverez quelques petites astuces pour rendre les formulaires plus accessibles et pratiques à utiliser. On y fera également un petit point sur l'emploi de javascript pour la validation ceux-ci.

Les balise oubliées du web

Titre étrange me direz-vous, mais admettons que beaucoup de sites se privent de l'emploi des balises que nous allons voir. Et pour cause, elles ne sont absolument pas indispensables au bon fonctionnement d'un formulaire. Cependant, leur emploi pourra faciliter l'utilisation de vos formulaires par vos visiteurs, alors utilisez-les!

Label

Tout champ d'un formulaire dispose de son propre label. Ils ne sont cependant que rarement identifiés comme tel dans le code HTML. Pour ce faire, on utilise simplement la balise <label> pour encadrer label d'un champ. Voyons un petit exemple :

<p><label>Nom : <input type="text" name"nom" /></label></p>

Vous remarquerez dans cet exemple que la balise <label> englobe le champ et son label. Cela sous entend que ce label et ce champ son associés. Cependant, certaines mise en page ne permettront pas de les associer sur la même ligne de code. Pour remédier à cela, il est possible d'attribuer au champ concerné un id et de l'indiquer dans l'attribut for de la balise <label>. On procédera alors ainsi :

<p><label for="nom">Nom</label></p>
<p><input type="text" name="nom" id="nom" /></p>

L'emploi de cette balise entraînera, pour le navigateur, une association entre le champ et son label. Ainsi le fait de cliquer sur le texte correspondant au champ placera automatique le focus sur le champ concerné.

Fieldset

Grouper les champs d'un formulaire lorsque cela est utile et faisable est un plus non négligeable pour un formulaire. Pour cela nous disposons de deux balises : <fieldset> et <legend>. La première permet d'englober différents champs de votre formulaire portant sur le même type de données. La seconde permet de donner une légende à ce groupe de champs. Elles s'utilisent ainsi :

<fieldset>
  <legend>Nom</legend>
  <p><label>Nom : <input type="text" name="nom" /></label></p>
  <p><label>Pr&eacute;nom : <input type="text" name="prenom" /></label></p>
</fieldset>
<fieldset>
  <legend>Adresse</legend>
  <p><label>Addresse : <textarea name="addresse" ></textarea></label></p>
  <p><label>Code postal : <input type="text" name="postcode" /></label></p>
</fieldset>
...

Vous pouvez voir, dans cet exemple, de quelle manière nous pouvons grouper les différents champs d'un formulaire. Attention tout de même ne pas grouper à outrance et à n'employer ceci que lorsque que c'est nécessaire. Il ne s'agit pas ici de travailler la mise en forme.

Groupes d'options, optgroup

Il s'agit ici de grouper les options d'une liste par catégories. Ceci évitera, par exemple, l'emploi de fausses options comme on peut le voir sur certains sites. Pour cela, il existe la balise <optgroup> qui doit être utiliser directement dans la liste des options d'une liste. Elle dispose d'un attribut label qui permet de définir quel texte sera afficher pour le groupe d'options.

<select name="pays">
  <optgroup label="Europe">
    <option value="fr">France</option>
    <option value="uk">Royaule Uni</option>
  </optgroup>
  <optgroup label="Am&eacute;rique">
    <option value="us">USA</option>
    <option value="ca">Canada</option>
  </optgroup>
</select>

Ceci produira, pour chaque <optgroup> une ligne dans la liste des options non sélectionnable et qui disposera d'une mise en forme particulière qui l'identifiera clairement comme une entête de catégorie.

Tabindex

Tabindex est un attribut de champs de formulaire. Il sert à définir dans quel ordre les champs devront être parcourut lorsque votre visiteur utilise la touche tab pour naviguer d'un champ à l'autre. Cet attribut se révélera particulièrement utile lorsque les champs n'apparaissent pas dans le même ordre dans le code html de la page et à l'affichage.

Il s'utilise très simplement de la façon suivante :

<fieldset>
  <legend>Nom</legend>
  <p><label>Nom : <input type="text" tabindex="1" name="nom" /></label></p>
  <p><label>Pr&eacute;nom : <input type="text" tabindex="2"  name="prenom" /></label></p>
</fieldset>
<fieldset>
  <legend>Adresse</legend>
  <p><label>Addresse : <textarea name="addresse" tabindex="3"></textarea></label></p>
  <p><label>Code postal : <input type="text" tabindex="4" name="postcode" /></label></p>
  <p><label>Pays : <select name="pays" tabindex="5">
    <optgroup label="Europe">
      <option value="fr">France</option>
      <option value="uk">Royaule Uni</option>
    </optgroup>
    <optgroup label="Am&eacute;rique">
      <option value="us">USA</option>
      <option value="ca">Canada</option>
    </optgroup>
  </select></label></p>
</fieldset>

A propos d'accesskey

Accesskey est également un attribut de champ. Il permet de définir, comme son nom l'indique, une touche d'accès. Comprenez un raccourci clavier. Cependant il est préférable de ne pas l'employer sur un site web. Il pourra éventuellement être utilisé pour une application Intranet. Voyez l'article d'Alsacreations pour en savoir plus à ce propos.

La validation d'un formulaire avec du Java Script

Ici je m'attaque à un problème récurent, réel et qui provoque chez moi un énervement destructeur pour la touche return de mon clavier! Alors je lance ici un appel à tous les développeurs, même amateurs et improvisés, pour le respect de quelques simples règles d'accessibilité dans le développement et le contrôle de saisies d'un formulaire via Java Script.

Après ces quelques mots, entrons maintenant dans le vif du sujet. Beaucoup de formulaires emploient du Java Script pour le contrôle des saisies de l'utilisateur. Ceci apporte son petit lots d'avantages : Évite à l'utilisateur d'attendre un rechargement de la page pour la vérification des données et diminue la bande passante utilisée par le site ou l'application (plutôt à long terme). Malheureusement, la manière dont est employé le code de vérification est souvent gênante (voir bloquante) pour certains utilisateurs.

Je ne vais pas m'étaler ici sur plusieur lignes supplèmentaire d'explication et je vais m'en remettre à un article d'OpenWeb. J'ai déjà donné ce lien dans un précédent post, mais il me parait tellement important que je le redonne ici : Validation des formulaires avec Java Script

Un arrière plan étirable

Thierry Geindre — Fri, 15 Feb 2008 22:32:00 +0000

Les propriétés CSS permettant d'appliquer une image d'arrière plan aux éléments d'une page, ou à la page elle même, ne permettent de couvrir toute la surface disponible que par répétition de l'image. Je vous propose ici une méthode permettant détirer l'image en hauteur et/ou en largeur en fonction de l'espace disponible. A noter qu'à l'inverse de beaucoup de solutions proposées sur la toile, celle que je vous propose n'utilise pas de java script.

Le principe

Les propriétés CSS ne satisfaisant pas nos exigences, nous allons devoir utiliser une autre technique. Pour cela, nous utiliserons une classique image (balise <img ... />). La méthode consistera en fait à lui donner des dimensions à 100%. Elle s'étirera donc automatiquement en fonction des éventuels changements de dimensions.

Puisqu'il s'agit d'un arrière plan, nous allons devoir placer du contenu par dessus. Pour cela, nous allons devoir modifier le mode de positionnement de ce contenu en fonction du contexte.

L'arrière plan d'une page

Pour cela nous allons d'abord supprimer les éventuelles marges du corps de la page. Nous lui donnerons également des dimensions à 100% sans quoi cette astuce ne fonctionnera pas sous certaines versions d'Internet Explorer.

Nous placerons ensuite note image de fond dans la première ligne de contenu de l'élément <body>. Les dimensions de cette images seront définies à 100%.

Enfin, pour que le contenu se place par dessus cette image, on pourra le placer dans un élément de type <div> (ou tout autre conteneur) que nous positionnerons en absolute.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" lang="fr">
 <head>
 <title>Un exemple</title>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
  <style type="text/css">
 
   body,html
   {
     /* Indispensables pour certain navigateurs */
     width:100%;
     height:100%;
     /* On retire les marges éventuelles */
     margin:0;
     padding:0;
    }
 
    #background
    {
     width:100%;
     height:100%;
    }
 
    #content
    {
     position:absolute;
     left:0;
     top:0;
    }
  </style>
 </head>
 <body>
   <img src="images/background.png" alt="" id="background" />
   <div id="content">
     <p>Le contenu de la page se place dans ce div!</p>
   </div>
 </body>
</html>

Vous pouvez vérifier le bon fonctionnement de cette astuce grâce à l'aperçu que je vous propose. Redimensionnez la fenêtre et observez l'image prendre les bonnes dimensions. Vous remarquerez en passant que les proportions de l'image ne sont pas forcément respectées. Si vous souhaitez conserver les bonnes proportions, il vous suffira de ne préciser la dimension 100% que pour la hauteur ou la largeur de l'image.

Vous remarquerez peut être que cette page n'est pas valide. En effet, une balise <img ... /> ne peut normalement pas apparaître dans ce contexte, il faudrait logiquement qu'elle soit placé entre des éléments <h1> ou <p> par exemple. Cependant, en plus d'être impossible à justifier à cette endroit, l'utilisation de ces balises ne permet pas d'obtenir le comportement attendu sur certain navigateurs.

Remarquez enfin que nous avons laissé le texte alternatif de l'image vide. Ceci s'explique simplement : aucun texte alternatif n'aurait de sens à cette endroit. De plus, si pour une raison ou une autre il apparaissait, il pourrait nuire à la bonne lecture de la page par le visiteur (superposition de texte).

Conclusion

Il est probablement préférable d'utiliser cette astuce avec modération. Je n'ai pas eu l'occasion de la tester sur beaucoup de navigateurs. Alsacreations nous indique que cette technique fonctionne sur les navigateurs suivant : sur Windows IE5, IE5.5, IE6, Mozilla Firebird 0.7, Mozilla Firefox 0.8 et Opera 7.23. Pour ma part, j'ai pu vérifier avec les versions Linux de Firefox 2.0 et Opera.

Vous pourrez également appliquer cette méthode à d'autre éléments de votre page. La technique restant rigoureusement la même.

Upload de fichiers via formulaire avec PHP

Thierry Geindre — Mon, 14 Jan 2008 16:10:00 +0000

L'utilisation d'un langage côté serveur permet d'automatiser ou de simplifier bon nombre de tâches d'administration. L'upload (envoi) de fichiers fait partie de ces tâches qui peuvent être simplifiées. En effet, il est possible d'envoyer vos fichiers via un formulaire sur une page web puis d'effectuer le traitement de celui-ci grâce à PHP. Il ne sera donc plus nécessaire d'utiliser à chaque fois un client FTP.

Ceci pourra être très pratique dans le cas de l'administration d'une galerie photo par exemple, ou encore simplement pour illustrer vos publications.

Pré requis

Droits d'écriture

Pour que l'upload de fichiers puisse fonctionner correctement, il est impératif que le répertoire dans lequel on souhaitera placer les fichiers soit accessible en écriture. Sur certains systèmes, les dossiers sont toujours accessibles en écriture, c'est le cas de Windows (< Vista). En revanche, sur d'autres, tel que les systèmes dérivés d'UNIX, il est possible d'interdire l'écriture dans certains répertoires.

Ce réglage ne sera donc nécessaire que si le système de la machine qui héberge votre site utilise un mécanisme de gestions de droits sur les fichiers et répertoires.

Pour autoriser l'écriture, vous avez plusieurs possibilités. Soit en utilisant votre client FTP, auquel cas vous pourrez modifier les droits en accédant aux attributs ou aux propriétés de votre répertoire. Vous pouvez également modifier les droits de votre répertoire grâce à la fonction chmod() de PHP (reportez-vous à la documentation). Enfin, si vous avez accès directement au système de la machine (par SSH par exemple), vous pourrez modifier les droits très facilement grâce aux commandes appropriées (reportez vous à la documentation de votre système).

Configuration de php (php.ini)

Pour que l'envoie de fichiers fonctionne, PHP doit être configuré de la bonne manière. Ainsi certaine directives doivent avoir certaines valeurs. Vous pouvez modifier ces valeurs dans le fichier php.ini ou grâce à la fonction ini_set().

file_uploads est la directive qui autorise ou interdit l'upload de fichier. Sa valeur doit donc être on (inverse de off).
upload_tmp_dir correspond au répertoire dans lequel seront placé les fichiers temporairement uploadés. Ce répertoire doit lui aussi être accessible en écriture. Sur les systèmes UNIX et dérivés il s'agira souvent du répertoire /tmp/ accessible en écriture pour tous les utilisateurs du système.
upload_max_filesize détermine la taille maximal de l'envoi d'un fichier. Il n'y a pas de valeur parfaite mais 2M est une valeur courante et satisfaisante dans la plupart des cas. Elle correspond à 2 méga octets.
post_max_size correspond au volume maximum d'informations qui peuvent être envoyées via la méthode POST. Cette directive prime sur la précédente et doit logiquement avoir une valeur au moins égale. C'est pourquoi, là encore, 2M est une valeur satisfaisante.

Si vous rencontrez des difficultés dans l'upload de vos fichiers avec la méthodes que nous allons voir, c'est probablement à cause de votre configuration. SI vous ne pouvez pas y avoir accès (cas des hébergement mutualisés), utilisez la fonction phpinfo() qui vous donnera toutes les informations de configuration de php.

Le formulaire HTML

La première étape est de créer notre formulaire en HTML qui permettra l'envoie de fichiers au serveur. Pour cela, nous allons devoir préciser type de données qui sera envoyé via notre formulaire. Ce type est définit par défaut à application/x-www-form-urlencoded et ne permet pas l'envoie de fichiers. Nous allons le modifier au moyen de l'attribut enctype de la balise form et luis donner pour valeur multipart/form-data ce qui permettra l'envoie de n'importe quel type de données.

Enfin, pour permettre la sélection du fichier par le client, nous utiliserons un élément de formulaire de type file.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" lang="fr">
 <head>
  <title>Formulaire d'upload</title>
 </head>
 <body>
  <form method="post" enctype="multipart/form-data" action="upload.php">
   <p>
    <label>S&eacute;lectionnez un fichier :
    <input type="file" name="fichier" />
    </label>
   </p>
   <p><input type="submit" value="Envoyer" /></p>
  </form>
 </body>
</html>

Cet exemple de formulaire permet d'envoyer un seul fichier sur le serveur. Ce fichier sera placé dans un répertoire contenant des fichiers temporaires et, s'il ne fait pas l'objet d'un traitement supplémentaire, il sera supprimé à la fin de l'exécution de la requête. C'est pourquoi nous allons devoir faire intervenir PHP.

Le script PHP

Passons maintenant au script chargé du traitement approprié. Nous allons dans un premier temps en voir une version simple qui autorise tout types de fichiers.

Lorsque qu'un script reçoit les informations transmises par un formulaire, on utilise habituellement la variable globale $_POST pour les lire. Cependant, pour les élément de type file, on devra récupérer les informations concernant le fichiers via la variable $_FILES. Il s'agit d'un tableau associatif contenant différentes informations concernant les fichiers envoyés. La structure de ce tableau est la suivante :

Array
(
    [nom_du_champ_file] => Array
        (
            [name] => "MaBelleImage.jpg" // Nom du fichier
            [type] => "image/jpg" // type de fichier
            [tmp_name] => "chemin_complet_du_fichier_uploadé" // Emplacement temporaire
            [error] => 0 // Code d'erreur si erreur il y a
            [size] => 1000 // Taille du fichier
        )
)

A partir de ces informations, nous pourrons effectuer différents contrôles que nous verrons un peu plus tard. Pour le moment, nous allons simplement sauvegarder le fichier envoyé.

<?php
  // On définit notre répertoire cible
  $dstRep = './fichiers/';
 
  // On vérifie qu'il est accessible en écriture
  if(!is_writable($dstRep))
    die('Impossible d\'écrire dans le répertoire cible.');
 
  // On vérifie d'abord que des données ont bien été envoyées
  if(!isset($_FILES['fichier']))
    die('Aucune données');
 
  // On finit par déplacer le fichier dans le répertoire cible
  move_uploaded_file($_FILES['fichier']['tmp_name'],$dstRep.$_FILES['fichier']['name']);
 
?>

Bien que ce script soit théoriquement fonctionnel, il est très imparfait. En effet, il ne contrôle pas le bon déroulement de l'envoie du fichier au moyen des codes d'erreur pouvant être indiqués dans le tableau $_FILES. En effet, la valeur de ce code nous indique le type d'erreur qui s'est produite durant l'envoie.

<?php
  // On définit notre répertoire cible
  $dstRep = './fichiers/';
 
  // On vérifie qu'il est accessible en écriture
  if(!is_writable($dstRep))
    die('Impossible d\'écrire dans le répertoire cible.');
 
  // On vérifie d'abord que des données ont bien été envoyées
  if(!isset($_FILES['fichier']))
    die('Aucune données');
 
  // Vérification du code d'erreur
  switch($_FILES['fichier']['error'])
  {
     case 1: // UPLOAD_ERR_INI_SIZE
        die("Le fichier dépasse la limite autorisée par le serveur (fichier php.ini) !");
        break;
      case 2: // UPLOAD_ERR_FORM_SIZE
        die("Le fichier dépasse la limite autorisée dans le formulaire HTML !");
        break;
      case 3: // UPLOAD_ERR_PARTIAL
        die("L'envoi du fichier a été interrompu pendant le transfert !");
        break;
      case 4: // UPLOAD_ERR_NO_FILE
        die("Le fichier que vous avez envoyé a une taille nulle !");
        break;
  }
 
  // On finit par déplacer le fichier dans le répertoire cible
  move_uploaded_file($_FILES['fichier']['tmp_name'],$dstRep.$_FILES['fichier']['name']);
 
?>

Ainsi, ce script ne devrait pas lever d'erreur. A noter que d'autres types d'erreurs ont été introduit avec les nouvelles versions de PHP. Cependant, il reste assez incomplet. Nous allons maintenant lui ajouter quelques fonctionnalités supplémentaires. Et pour commencer, une indispensable, éviter l'écrasement des fichiers.

Éviter l'écrasement de fichier

Le problème que risque de poser le script que nous avons vu est l'écrasement de fichiers déjà existant. En effet, si vous envoyez deux fichiers portant le même nom, le premier fichier sera écrasé par le second. Pour remédier à cela, je vous propose une solution assez simple qui consiste à préfixer le nom du fichier d'un chiffre. Il existe d'autres solutions mais celle-ci est assez efficace et durable.

<?php
  // On définit notre répertoire cible
  $dstRep = './fichiers/';
 
  // On vérifie qu'il est accessible en écriture
  if(!is_writable($dstRep))
    die('Impossible d\'écrire dans le répertoire cible.');
 
  // On vérifie d'abord que des données ont bien été envoyées
  if(!isset($_FILES['fichier']))
    die('Aucune données');
 
  // Vérification du code d'erreur
  switch($_FILES['fichier']['error'])
  {
     case 1: // UPLOAD_ERR_INI_SIZE
        die("Le fichier dépasse la limite autorisée par le serveur (fichier php.ini) !");
        break;
      case 2: // UPLOAD_ERR_FORM_SIZE
        die("Le fichier dépasse la limite autorisée dans le formulaire HTML !");
        break;
      case 3: // UPLOAD_ERR_PARTIAL
        die("L'envoi du fichier a été interrompu pendant le transfert !");
        break;
      case 4: // UPLOAD_ERR_NO_FILE
        die("Le fichier que vous avez envoyé a une taille nulle !");
        break;
  }
 
  // On vérifie si le fichier existe déjà dans le répertoire cible
  if(file_exists($dstRep.$_FILES['fichier']['name']))
  {
    // On utilise une boucle pour incrémenter notre préfixe
    $i = 0;
    while(file_exists($dstRep.$i.'_'.$_FILES['fichier']['name']) ) $i++
 
    // Arrivé ici, on a trouvé un nom disponible avec un préfixe numérique
    $cible = $dstRep.$i.'_'.$_FILES['fichier']['name'];
  }
  else
  {
    // Le fichier n'existe pas dans le répertoire cible,
    // Nous pouvons donc utiliser le nom original
    $cible = $dstRep.$_FILES['fichier']['name'];
  }
 
  // On finit par déplacer le fichier dans le répertoire cible
  move_uploaded_file($_FILES['fichier']['tmp_name'],$cible);
 
?>

Avec cette nouvelle version, les fichiers ne pourront pas être écrasés. Nous allons maintenant voir comment limiter l'envoie à certains types de fichiers.

Limiter les types de fichiers autorisés

Pour instaurer cette limitation, on pourrait éventuellement se baser sur l'information de type (Type mime) contenue dans le tableau $_FILES. Cependant, cette information est fournit par le client, le navigateur. La règle d'or en matière de développement web est de ne jamais avoir confiance dans les données transmises par un tiers inconnu. D'autre part, cette information pourra être un peut différente pour un même type de fichier et des navigateurs différents. Pour ces raisons, on ne tiendra pas compte de cette information.

Idéalement, il faudrait utiliser une méthode consistant à rechercher le type mime à partir du contenu du fichier. Il existe, pour cela la, fonction mime_content_type() mais elle est désormais déprécier au profit de Fileinfo.

Pour faire simple ici, nous baserons notre test sur l'extension du fichier. Pour que cette méthode soit suffisamment sûr, il est important que votre serveur soit correctement configuré pour ne pas exécuter de code côté serveur dans des fichiers ne portant pas une extension propre au langage. On a pu voir, par exemple, des serveurs autorisant l'exécution de code PHP dans fichiers portant l'extension .jpg, ce qui est un peu douteu...

<?php
  // On définit notre répertoire cible
  $dstRep = './fichiers/';
 
  // On créé un tableau contenant les extensions autorisées
  $extOk = array('.jpg','.gif','.png');
 
  // On vérifie qu'il est accessible en écriture
  if(!is_writable($dstRep))
    die('Impossible d\'écrire dans le répertoire cible.');
 
  // On vérifie d'abord que des données ont bien été envoyées
  if(!isset($_FILES['fichier']))
    die('Aucune données');
 
  // Vérification du code d'erreur
  switch($_FILES['fichier']['error'])
  {
     case 1: // UPLOAD_ERR_INI_SIZE
        die("Le fichier dépasse la limite autorisée par le serveur (fichier php.ini) !");
        break;
      case 2: // UPLOAD_ERR_FORM_SIZE
        die("Le fichier dépasse la limite autorisée dans le formulaire HTML !");
        break;
      case 3: // UPLOAD_ERR_PARTIAL
        die("L'envoi du fichier a été interrompu pendant le transfert !");
        break;
      case 4: // UPLOAD_ERR_NO_FILE
        die("Le fichier que vous avez envoyé a une taille nulle !");
        break;
  }
 
  // On lit l'extension du fichier
  $fileExt = substr($_FILES['fichier']['name'],-4,4);
 
  // On vérifie que l'extension est dans le tableau
  // des extensions autorisées
  if(in_array($fileExt,$extOk))
    die("Type de fichier non autorisé.");
 
  // On vérifie si le fichier existe déjà dans le répertoire cible
  if(file_exists($dstRep.$_FILES['fichier']['name']))
  {
    // On utilise une boucle pour incrémenter notre préfixe
    $i = 0;
    while(file_exists($dstRep.$i.'_'.$_FILES['fichier']['name']) ) $i++
 
    // Arrivé ici, on a trouvé un nom disponible avec un préfixe numérique
    $cible = $dstRep.$i.'_'.$_FILES['fichier']['name'];
  }
  else
  {
    // Le fichier n'existe pas dans le répertoire cible,
    // Nous pouvons donc utiliser le nom original
    $cible = $dstRep.$_FILES['fichier']['name'];
  }
 
  // On finit par déplacer le fichier dans le répertoire cible
  move_uploaded_file($_FILES['fichier']['tmp_name'],$cible);
 
?>

Le système que nous venons de voir ne permet que de tester les extensions d'une longueur de trois caractère et nécessitera quelques modifications pour tester des extensions plus longue. Cependant, par convention, on se limite à 3 caractères pour l'extension d'un fichier.

Conclusion

Nous avons vu l'upload de fichiers avec PHP et quelques test pour aller un peu plus loin. Permettez moi un conseil, restez prudent avec l'envoie de fichiers car ceci peu ouvrir d'énormes failles sur vos sites. N'hésitez donc pas mettre en œuvre le maximum de test de sécurité sur les données envoyées.