Réalisation de sites web

Sommaire du site

Présentation
Comment apprendre
L'équipement
La page web
  Styles et CSS
  HTML, structure de la page
  HTML, éléments du corps
Le langage JavaScript
  JavaScript, objets "core"
  JavaScript, DOM, les bases
  JavaScript, DOM, node
  JavaScript, compléments
Le langage PHP, les bases
  PHP, fonctions utiles
  PHP pour le web
  PHP, compléments
SQL, introduction
  MySQL et PHP pour le web
  MySQL, plus loin...
Applications AJAX
Annexes utiles
  Fichier .htaccess
  Sécurité des sites web
  Conception d'un site web
  Référencement, syndication

Sommaire détaillé

Mentions légales.

Chapitres de cette page
Contenu  -> 

Page mise à jour le : 12-08-2015

Haut de la page

Expressions rationnelles
Système de fichiers

Images
Et encore...
A suivre...

PHP, compléments

Expressions rationnelles (régulières)

PHP dispose de fonctions de traitement des expression rationnelles ou régulières. Il s'agit essentiellement de recherche dans des textes de fragments assimilables à un certain motif (l'expression rationnelle). On a déjà vu cela en JavaScript.

En fait, PHP dispose de deux ensemble de fonctions pour traiter ces expressions :

Dans un cas comme dans l'autre, il s'agit de rechercher une partie de texte par la description d'un certain motif. Il est donc imporatn de bien savoir comment défini ce motif.

Pour cela, et comme le sujet est assez important, je vous conseille la lecture du site : http://www.expreg.com/ très complet sur ce sujet et aussi une page de test utile pour vérifier vos propres expressions rationnelles : http://www.chapellut.fr/demo/exp_reg/match.php version PRCE uniquement.
(Il est nécessaire d'avoir bien lu la documentation sur les fonctions PHP " preg_match" et " preg_match_all" auparavant).

Système de fichiers

PHP comme langage de programmation complet donne accès au système de fichiers du serveur. Il dispose donc des fonctions de gestion des fichiers.

Structure du système de fichiers

La plupart des systèmes d'exploitation de serveur reposent sur un système de fichiers de type POSIX (souvent le système est LINUX), nous présenterons la structure sous un tel système.
Toutefois les développeurs doivent savoir sous quel système fonctionne leur serveur. On trouve cette information par la fonction PHP 'phpinfo();'.
Comme il est probable que beaucoup de lecteurs de ce site sont plutôt familiarisés avec Microsoft Windows, les quelques différences seront précisées au cours de cette page.

Comme sur la plupart des systèmes les fichiers sont accessibles par des répertoires (dossiers pour les amateurs de Windows). Et un répertoire peut, lui aussi, contenir des répertoires d'où la structure arborescente du système de fichiers.

Chaque répertoire contient deux "sous-répertoires" particuliers :

Sur les systèmes de fichiers de type UNIX, il n'y a pas de notion de lecteur (C:..), le répertoire de plus haut niveau : racine est noté '/' (et non pas '\' comme chez Microsoft).

On peut accéder à un élément (fichier ou répertoire) du système de fichiers en donnant son chemin absolu (à partir de la racine) et en spécifiant les répertoires traversés. Le séparateur est à nouveau le caractère '/', comme :

/home/dupont/www/index.php

Il est aussi possible d'y accéder en donnant un chemin relatif au répertoire depuis lequel est passé la commande (en PHP le répertoire du script dans lequel est l'instruction). Dans ce cas le chemin ne débute pas par '/' :

medias/demo/formulaire.php
ou (c'est pareil) :
./medias/demo/formulaire.php

Notons aussi que sur ces systèmes, des droits d'accès sont associés aux répertoires et fichiers. Certains peuvent être interdits de lecture, d'autres interdits de modification. Par conséquent sur un serveur mutualisé, il convient de rester dans la zone qui a été allouée. Les tentatives d'accès aux autres endroits sont souvent enregistrées et on peut encourir des problèmes.

Fonctions PHP pour  parcourir le système de fichiers

Il suffit de trois fonctions :

opendir(rep); initialise le parcours dans le répertoire 'rep', renvoie un pointeur pour les autres fonctions ou FALSE si erreur.

readdir(pointeur);  renvoie le nom du fichier du répertoire indexé par 'pointeur' et fait avancer 'pointeur'. Renvoie FALSE s'il n'y a plus de fichiers ou en cas d'erreur.

closedir(pointeur); libère la ressource.

Exemple, lister le répertoire courant :

$rep= opendir('.');
if ($rep) {
  while (($nom_fic = readdir($rep)) !== false)
    echo "$nom_fic<br>";
  closedir($rep);
}
Les amateurs de programmation objet trouveront des fonctionnalités équivalentes dans la classe 'Directory'.

Notez qu'il n'y a pas d'ordre particulier d'affichage, celui-ci dépend du système.

Depuis PHP 5, on a une autre fonction plus rapide et plus pratique.

scandir(rep, sens); renvoie un tableau des noms de fichiers trouvés dans 'rep'. Si 'sens' vaut 0 ou est absent, le tableau est classé dans l'ordre alphabétique, si 'sens' vaut 1 le classement  sera l'ordre alphabétique inverse.

Informations sur un fichier

Il existe une fonction 'stat(chemin)' qui renvoie un tableau contenant toutes les informations sur le fichier spécifié par 'chemin'. Comme, en général, on n'a pas besoin de tout cela on préfère utiliser des fonctions plus spécifiques.

is_file(chemin); renvoie TRUE si 'chemin' indique un véritable fichier.
is_dir(chemin); renvoie TRUE si 'chemin' indique un répertoire.

filesize(chemin); renvoie la taille en octets du fichier passé en paramètre..

fileatime(chemin)filemtime(chemin); renvoient les date-heure (respectivement) du dernier accès, de la dernière modification du fichier passé en paramètre. La valeur renvoyée est un "timestamp".

basename(chemin); renvoie simplement le nom du fichier se trouvant au bout du 'chemin';
dirname(chemin); renvoie le chemin d'accès (sans le nom du fichier) du paramètre.
realpath(chemin); renvoie le chemin absolu (éventuellement simplifié) de 'chemin'.

Exemple, parcours d'une arborescence :

function Repertoire($chemin, $decal) {
  echo "<b>$chemin</b><br>";
  $rep= opendir($chemin);
  if ($rep) {
    while (($nom_fic = readdir($rep)) !== false) {
      if (strlen($nom_fic) < 1 || $nom_fic[0] == '.') continue;
      $nom_fic= $chemin.'/'.$nom_fic;
      if (is_dir($nom_fic)) Repertoire($nom_fic, $decal+2);
      else {
        echo str_pad("", $decal, " ");
        echo realpath($nom_fic)." - ".filesize($nom_fic)."<br>";
      }
    }
    closedir($rep);
  }
}

echo "<pre>";
Repertoire('.', 2);
echo "</pre>";

La fonction 'Repertoire' est récursive (elle s'appelle elle-même). Elle reçoit un paramètre '$chemin' indiquant le répertoire à lister et '$decal' qui est une valeur d'indentation d'affichage.

    (La fonction 'str_pad' produit une chaine de longueur '$decal' composée ici d'espaces.)

Dans sa boucle, on commence par ne pas tenir compte des fichiers dont le nom commence par '.' pour éviter une récursion infinie.

Si l'élément vu est un répertoire on rappelle cette fonction en lui passant ce répertoire et une indentation plus grande.

Sinon on affiche le nom (chemin complet) et la taille du fichier.

Copie, déplacement et suppression

copy(source, destination); duplique le fichier 'source' en 'destination'.

rename(ancien, nouveau); si 'ancien' et 'nouveau' indiquent le même répertoire, 'ancien' est renommé en 'nouveau'. Si ce sont des répertoires différents, 'ancien' est déplacé vers 'nouveau'.

unlink(fichier); supprime le fichier 'fichier'.

Les connaisseurs d'UNIX et dérivés savent que sur ces systèmes un fichier peut avoir plusieurs noms.
En fait, 'unlink' supprime un nom de fichier et, dans le cas où c'était le seul, supprime effectivement le fichier.

Lecture et écritures

readfile(fichier); envoie en sortie le contenu du fichier passé en paramètre. Si le fichier ne contient pas de '<?php ... ?>' c'est semblable à  'include()'.

file_get_contents(fichier); renvoie sous forme de chaîne le contenu du fichier passé en paramètre.

file_put_contents(fichier, contenu); crée le fichier 'fichier' en lui donnant comme contenu 'contenu'. Si le fichier existait déjà son ancien contenu est détruit et remplacé.

file_put_contents(fichier, contenu, FILE_APPEND); crée le fichier 'fichier' en lui donnant comme contenu 'contenu'. Si le fichier existait déjà 'contenu' est ajouté en fin de fichier.

Il existe aussi des fonctions plus traditionnelles (fopen, fread, fwrite, ...) qui sont moins utilisées car moins rapides et plus complexes à mettre en oeuvre bien qu'elles puissent rendre des services pour une gestion fine du contenu des fichiers.

Images

La bibliothèque "gd" du PHP contient une centaine de fonctions de traitement d'images.

Avant des les utiliser, il faut s'assurer que cette bibliothèque est bien intégré au serveur (avec phpinfo();)

Pour traiter une image il faut :

Dans tous les cas ces fonctions renvoient un identifiant de ressource d'image (en cas de réussite).

Ensuite toute une panoplie de fonctions permet de dessiner dans l'image ou de la modifier.

Enfin il faut soit enregistrer l'image dans un fichier soit l'afficher.

Pour cela on utilise les fonctions 'imagejpeg(...)',   'imagepng(...)', ... Ces fonctions ont un premier paramètre obligatoire qui est l'identifiant de ressource d'image, éventuellement un deuxième paramètre qui est le nom du fichier à produire, s'il est absent ou vaut NULL l'image sera produite dans le document. Selon les formats d'autres paramètres peuvent être présents (qualité...).

Lorsque les ressources images n'ont plus de rôle à jouer, on libère la mémoire qu'elles occupaient avec 'imagedestroy(ressource);'

Exemple d'application

Réduction d'une image pour produire une miniature.

Voir la démonstration  (nouvelle fenêtre ou onglet).

Dans cet exemple, la liste (en haut à droite) permet de choisir un facteur de réduction. L'image est affichée au dessous dans un élément 'iframe'. Son contenu est réalisé en PHP, il est présenté ci-dessous.

header("Content-type: image/jpeg");
$image_org = imagecreatefromjpeg("viaduc.jpg");
list($lg_org, $ht_org) = getimagesize("viaduc.jpg");
$zoom= (isset ($_POST['zoom']) ? $_POST['zoom'] : 100) / 100.0;
if ($zoom == 1)
  $image_red= $image_org;
else {
  $n_lg= round($zoom * $lg_org);
  $n_ht= round($zoom * $ht_org);
  $image_red = imagecreatetruecolor($n_lg, $n_ht);
  imagecopyresampled($image_red, $image_org,
        0, 0, 0, 0,
        $n_lg, $n_ht, $lg_org, $ht_org);
}
imagejpeg($image_red);
imagedestroy($image_org);
imagedestroy($image_red);

On remarque le 'header' indiquant le type des données produites.

Pour un changement de taille, on utilise deux ressources images : l'original et l'image réduite car la fonction de réduction 'imagecopyresampled()' fait un ré-échantillonnage d'une image vers l'autre. Son nombre important de paramètres permet de ne copier qu'une partie de l'image d'origine dans une partie de l'image de destination.

Et encore...

Il existe encore bien d'autres possibilités du PHP que l'on trouve sur le site :
http://www.php.net/manual/fr/funcref.php

Cependant pour beaucoup d'entre-elles il faut s'assurer qu'elles sont valides sur le serveur que l'on utilise.

Et si cela ne suffit pas on trouve sur le web des scripts prêts à l'emploi. Les lire est aussi un bon moyen de se perfectionner dans ce langage.

A suivre...

.C'est presque fini pour le PHP. Presque, car on aura l'occasion d'y revenir avec les fonctions de gestion de bases de données.