Accédez à nos cours concernant des domaines et thématiques différentes. Vous pouvez aussi contribuer en rédigeant des articles.
Consulter les coursParcourez notre annuaire d’écoles, instituts et universités du monde. Si votre école n’est pas listée, vous pouvez l’ajouter très facilement.
Consulter les écolesAccédez à notre messagerie instantanée pour échanger avec d’autres membres inscrits et aussi les invités. Aucune inscription n’est obligatoire.
Accéder au tchat“Le présent article n'a pas encore été revu par un modérateur, pour cela veuillez faire attention quant à son contenu, que nous ne pouvons pas vous garantir son exactitude.”
SPL (Standard PHP Librairy) est une extension écrite par Marcus Boerger, valable et compilée par défaut en PHP5. Elle apporte une collection de classes, de classes abstraites et d'interfaces qui permettent de solutionner élégamment des problèmes récurrents concernant le parcours de données en boucle. En effet, que ce soit le parcours des fichiers d'un répertoire, le parcours des résultats provenant d'une requête SQL, le parcours d'un fichier ligne par ligne, on retrouve de nombreux points communs.
Cette extension propose donc des solutions communes pour aborder tous ces traitements, ce qui permet de ne pas avoir à réinventer la roue à chaque fois, donc une meilleure réutilisabilité du code.
Pour cette introduction, nous prendrons en exemple la classe directoryIterator.
La classe directoryIterator propose des méthodes pour parcourir un répertoire et récupérer des informations sur les différentes entrées rencontrées. Elle implémente l'interface iterator.
Comme toute classe, il est possible d'appeler directement les méthodes publiques de la classe directoryIterator comme suit :
<?php
try {
$dir = new directoryIterator('.');
while( $dir->valid() ) {
echo $dir->getFilename() , '<br/>';
$dir->next();
}
} catch (Exception $e) {
echo $e;
}
?>
Pour afficher simplement la liste des fichiers contenus dans un répertoire, il est également possible d'utiliser une structure foreach. En effet, la classe directoryIterator implémente l'interface iterator, ce qui signifie que foreach ne va pas se contenter d'afficher les propriétés de l'objet, mais va appeler différentes méthodes (current(), next(), valid(), etc.) que la classe directoryIterator implémente.
Pour parcourir notre répertoire et afficher la liste des entrées, nous pouvons donc procéder comme suit :
<?php
try {
$dir = new directoryIterator('.');
foreach($dir as $value) {
echo $value, '<br/>';
}
} catch (Exception $e) {
echo $e;
}
?>
Il est donc possible, en utilisant l'héritage, de créer une classe sizeDirectoryIterator, qui étendra les fonctionnalités de la classe directoryIterator. On utilisera le polymorphisme pour réécrire la méthode current() pour qu'elle nous renvoie la taille de l'entrée courante , si c'est un fichier, au lieu de son nom.
Nous utiliserons à cet effet les méthodes suivantes :
<?php
class sizeDirectoryIterator extends directoryIterator implements iterator {
function current() {
return parent::isFile() ? parent::getSize() : 0;
}
}
try {
$S = new sizeDirectoryIterator('.');
foreach($S as $size) {
echo $size , '<br/>';
}
} catch (Exception $e) {
echo $e;
}
?>
Sur ce même principe, nous allons étendre les fonctionnalités de la classe directoryIterator en y ajoutant une méthode, isImage(), qui sera chargée de vérifier que l'entrée courante est une image. Nous réécrirons également la méthode valid() afin qu'elle tienne uniquement compte des images.
<?php
class imageFilesIterator extends directoryIterator {
function isImage() {
if(!parent::isFile() or !preg_match('`\.(gif|png|jpe?g)$`i', parent::getFilename()) ) {
return false;
}
return true;
}
function valid() {
if (parent::valid()) {
if (!$this->isImage()) {
parent::next();
return $this->valid();
}
return true;
}
return false;
}
}
try {
$O = new imageFilesIterator('.');
foreach ($O as $imageFile) {
echo $imageFile,'<br/>';;
}
} catch(Exception $e) {
echo $e;
}
?>
Voici une petite classe contenant une méthode récursive qui vous permettra d'afficher un arbre représentatif de la structure d'un répertoire.
Cette classe est basée sur la classe recursiveDirectoryIterator qui introduit deux méthodes supplémentaires par rapport à la classe directoryIterator :
<?php
class treeDirectory {
private $iterator = false;
public function __construct($directory) {
$this->iterator = new recursiveDirectoryIterator($directory);
}
public function displayTree($iterator = false) {
if(!$iterator) {
$iterator = $this->iterator;
}
echo '<ul>';
while($iterator->valid()) {
if($iterator->isDir() AND !$iterator->isDot()) {
echo '<li><strong style="color: red;">' , $iterator->current() , '</strong></li>';
if($iterator->hasChildren()) {
echo '<ul>' , $this->displayTree($iterator->getChildren()) , '</ul>';
}
} else {
if($iterator->isFile()) {
echo '<li>' , $iterator->getFilename() , '</li>';
}
}
$iterator->next();
}
echo '</ul>';
}
}
try {
$D = new treeDirectory('.');
$D-> displayTree();
} catch(Exception $e) {
echo '<pre>' , $e , '</pre>';
}
?>
Une amélioration possible de cette classe consisterait à définir une limite de profondeur pour la récursivité. N'hésitez-pas à la modifier et à nous la soumettre :)
 |
|
