La gestion des fichiers

De nombreuses applications travaillent sur des fichiers. Que ce soit pour les lire, les remplir, les supprimer ou même changer leur attributs. L’accès aux fichiers locaux est très rapide.

Si vous avez peu de traitements et de tris à faire sur le contenu, il est généralement plus performant d’utiliser des fichiers qu’une base de données.

Lecture rapide

La fonction file_get_contents() est la façon rapide pour lire le contenu d’un fichier dans un fichier. Elle utilisera un mappage de mémoire si ce mécanisme est supporté par votre système, afin d’améliorer les performances.

<?php
$homepage = file_get_contents('monfichier.txt');
echo $homepage;
?>

La fonction va retourner une chaîne de caractères avec l’intégralité du contenu.

Il existe aussi la fonction readfile(). Elle est différente de la précédente parce qu’elle envoie le contenu du fichier vers la sortie standard et retourne le nombre d’octets lus.

<?php
$file = 'monfichier.txt';
if (readfile($file)) {
    //le fichier à été correctement affiché
}  else {
    //rien n'est affiché
}
?>

Cette fonction est surtout utilisée pour forcer le téléchargement d’un fichier, voir le tutoriel en-tête php pour en savoir plus.

Lecture rapide de ligne à ligne

La fonction file(), prend en argument une adresse de fichier et retourne le contenu dans un tableau ligne à ligne. Les caractères de fin de ligne (\n ou \r) sont gardés et non éliminés dans l’opération. Tous les éléments du tableau, sauf éventuellement le dernier, contiennent donc un caractère de fin de ligne comme dernier caractère.

<?php
$tab = file('monfichier.txt');
for($i=0 ; $tab[$i]; $i++) {
    echo $tab[$i].'<br>';
}
?>

Ecriture rapide

Il n’existe qu’une fonction d’accès rapide pour écrire dans un fichier. La fonction file_put_contents() prend en paramètre une adresse de fichier et une chaîne de caractères. La chaîne est alors écrite dans le fichier. Si le fichier existe déjà, son contenu est écrasé.

<?php
// on lit le contenu du fichier
$recup = file_get_contents('monfichier.txt');
 
//on rajoute du contenu
$recup .= 'du contenu rajouté';
 
// on enregistre le nouveau contenu dans le même fichier
file_put_contents('monfichier.txt', $recup);
?>

Si le fichier n’existe pas il sera automatiquement crée.

Ouverture d’un fichier

Avant d’utiliser un fichier, il faut l’ouvrir (comme quand on ouvre un fichier texte avec un logiciel). La fonction fopen() permet de déclencher l’ouverture. elle prend deux paramètres : le nom complet (avec l’adresse) du fichier, et un mode d’ouverture.

<?php
$fp = fopen('monfichier.txt', 'r');
?>

Voici les différents modes d’ouverture:

•  ‘r’ : ouvre en lecture seule, et place le pointeur de fichier au début du fichier.
•  ‘r+’ : Ouvre en lecture et écriture, et place le pointeur de fichier au début du fichier.
•  ‘w’ : Ouvre en écriture seule ; place le pointeur de fichier au début du fichier et réduit la taille du fichier à 0. Si le fichier n’existe pas, on tente de le créer.
•  ‘w+’ : Ouvre en lecture et écriture ; place le pointeur de fichier au début du fichier et réduit la taille du fichier à 0. Si le fichier n’existe pas, on tente de le créer.
•  ‘a’ : Ouvre en écriture seule ; place le pointeur de fichier à la fin du fichier. Si le fichier n’existe pas, on tente de le créer.
•  ‘a+’ : Ouvre en lecture et écriture ; place le pointeur de fichier à la fin du fichier. Si le fichier n’existe pas, on tente de le créer.
•  ‘x’ : Crée et ouvre le fichier en lecture seule ; place le pointeur de fichier au début du fichier. Si le fichier existe déjà, fopen() va échouer, en retournant FALSE et en générant une erreur de niveau E_WARNING. Si le fichier n’existe pas, fopen() tente de le créer. Ce mode est l’équivalent des options O_EXCL|O_CREAT pour l’appel système open(2) sous-jacent. Cette option est supportée à partir de PHP 4.3.2 et fonctionne uniquement avec des fichiers locaux.
•  ‘x+’ : Crée et ouvre le fichier en lecture et écriture ; place le pointeur de fichier au début du fichier. Si le fichier existe déjà, fopen() va échouer, en retournant FALSE et en générant une erreur de niveau E_WARNING. Si le fichier n’existe pas, fopen() tente de le créer. Ce mode est l’équivalent des options O_EXCL|O_CREAT pour l’appel système open(2) sous-jacent. Cette option est supportée à partir de PHP 4.3.2, et fonctionne uniquement avec des fichiers locaux.

Lecture d’un fichier

Maintenant que nous avons ouvert notre fichier, il nous reste à lire son contenu. Nous avons pour cet usage quatre fonctions de base.

Lire caractère par caractère

La fonction fgetc() prend en paramètre le chemin du fichier, lit un caractère et le renvoie comme valeur de retour.

<?php
$fp = fopen('unfichier.txt', 'r');
if (!$fp) {
    echo "Impossible d'ouvrir le fichier unfichier.txt";
}
while (false !== ($char = fgetc($fp))) {
    echo "$char"."<br>";
}
?>

On affiche tous les caractères du fichier tant qu’il y en a à lire avec la boucle while. En effet, s’il y a plus de caractère à lire, alors la fonction renvoie FALSE.

Lire par ligne

La fonction fgets() retourne tous les caractères jusqu’à la prochaine fin de ligne (comprise). Elle permet de récupérer un fichier ligne après ligne.

Il faut spécifier comme deuxième paramètre une taille en octet. La fonction fgets() retournera au maximum ce nombre de caractères, même si aucune fin de ligne n’a été trouvée.

Il est fréquent de spécifier une taille arbitraire de 1024 octets pour lire toute la ligne. Si la chaîne retournée ne se termine pas par une fin de ligne et contient moins de caractères que le maximum autorisé, c’est qu’on est arrivé en fin de fichier.

<?php
$handle = @fopen("/tmp/inputfile.txt", "r");
if ($handle) {
    while (($buffer = fgets($handle, 4096)) !== false) {
        echo $buffer;
    }
    if (!feof($handle)) {
        echo "Erreur: fgets() a échoué\n";
    }
    fclose($handle);
}
?>

La fonction feof() permet de tester la fin du fichier.

Lire un fichier entier

La fonction fread() permet de lire plusieurs octets en une fois et retourne une chaîne de caractères. Le nombre d’octet à lire est à spécifier en second paramètre, après le desripteur de fichier.

La fonction filesize() permet de récupérer directement la taille d’un fichier.

<?php
// on mémorise le chemin du fichier
$filename = "something.txt";
 
// on ouvre le fichier
$handle = fopen($filename, "r");
 
// on lit et mémorise tout le contenu
$contents = fread($handle, filesize($filename));
 
// on ferme le fichier
fclose($handle);
?>

La fonction fclose() ferme le fichier.

Ecriture dans un fichier

Il existe une seule fonction d’écriture simple : fwrite(). Elle prend en paramètre le descripteur de fichier et la chaîne à insérer dans le fichier

<?php
$fp = fopen('data.txt', 'w');
fwrite($fp, '1');
fwrite($fp, '23');
fclose($fp);
// le contenu de 'data.txt' est maintenant 123 et non 23 !
?>

Pour écrire sur un fichier existant en mode rajout, utiliser ‘a’ comme second paramètre de la fonction fopen().

<?php
$filename = 'test.txt';
$somecontent = "Ajout de chaîne dans le fichier\n";
$handle = fopen($filename, 'a');
fwrite($handle, $somecontent);
?>

Si une taille est fournie comme troisième argument à fwrite(), alors elle spécifie la taille maximale de la chaîne à écrire.

<?php
$fp = fopen('data.txt', 'w');
$chaine = "voici mon texte complet";
fwrite($fp , $chaine, 9);
fclose($fp);
// le contenu de 'data.txt' sera ' voici mon'
?>

Position dans le fichier

Le système garde en mémoire un pointeur de position dans le fichier. Il est possible de définir manuellement une position. C’est utile pour revenir au début du fichier ou retenir une position pour revenir par la suite. Trois fonctions permettent de traiter les opérations courantes sur ce pointeur de position.

Placer le pointeur en début de fichier

La fonction rewind() permet de revenir en début de fichier, à l’octet zéro :

<?php
// création du fichier en mode ecriture-lecture
$handle = fopen('output.txt', 'r+');
// ecriture de la chaine
fwrite($handle, 'Really long sentence.');
// place le pointeur au début
rewind($handle);
// écris les tois caractères
fwrite($handle, 'Foo');
// place le pointeur au début
rewind($handle);
echo fread($handle, filesize('output.txt')); // resultat 'Foolly long sentence.'
// fermeture du fichier
fclose($handle);
?>

Placer le pointeur en un point

La fonction fseek() permet de positionner le pointeur de position à un certain endroit dans le fichier. Elle prend en paramètre le descripteur de fichier et un nombre d’octets.

<?php
$fp = fopen('somefile.txt', 'r');
// lit quelques données
$data = fgets($fp, 4096);
// retourne au début du fichier
fseek($fp, 0); // identique à rewind($fp);
?>

Détecter la position du curseur

La fonction ftell() permet de connaître la position actuelle du pointeur à partir du descripteur de fichier.

<?php
// Ouvre un fichier et y lit quelques données
$fp = fopen("/etc/passwd", "r");
$data = fgets($fp, 12);
// Où en sommes-nous ?
echo ftell($fp); // 11
fclose($fp);
?>

Détection de fin de fichier

Pour tester si le pointeur de position est à la fin du fichier, on utilise la fonction feof();

<?php
// On ouvre le fichier en mode lecture
$file = fopen("chaine.txt", "r");
//lit tous les caractères un à un
while (!feof($file)) {
fgetc($file);
}
fclose($file);
?>

Fermeture d’un fichier

Une fois que le fichier à été manipulé il faut le fermer. Cette action permet au système de libérer les ressources associées au fichier. Afin de ne pas surcharger le système, il est important de fermer les fichiers ouverts une fois qu’on a fini de les utiliser. Pour ce faire, il suffit d’utiliser la fonction fclose() en lui donnant le descripteur de fichier en argument.

<?php
$handle = fopen('somefile.txt', 'r');
fclose($handle);
?>

Gestion du tampon

Lors des écritures dans les fichiers, les données écrites sont inscrites en mémoire plutôt que directement dans le fichier. Elles ne sont recopiées sur le disque que par paquets ou à la fermeture, afin de minimiser les appels système et les accès disque.

Il est pourtant possible de demander à php de forcer l’écriture de toutes les données se trouvant actuellement dans le tampon mémoire grâce à la fonction fflush(). Elle prend en unique argument le descripteur de fichier.

<?php
$filename = 'bar.txt';
$file = fopen($filename, 'r+');
rewind($file);
fwrite($file, 'Foo');
fflush($file);
ftruncate($file, ftell($file));
fclose($file);
?>

Dans cette exemple on positionne le pointeur au début du fichier, on écrit ‘Foo’ puis on tronque le reste avec la fonction ftruncate() à partir de la position du pointeur détecter par ftell() (voir plus haut).

Accès concurrent

Pour éviter les erreurs lorsque plusieurs scripts utilisent un même fichier simultanément, il est possible de verrouiller un fichier quand on l’utilise avec la fonction flock().

Elle prend en paramètre le descripteur de fichier et soit LOCK_SH ou soit LOCK_EX.

•  LOCK_SH pour acquérir un verrou partagé (lecture).
•  LOCK_EX pour acquérir un verrou exclusif (écriture).
•  LOCK_UN pour libérer un verrou (partagé ou exclusif).
•  LOCK_NB si vous voulez que flock() ne se bloque pas durant le verrouillage. (non supporté sous Windows)

<?php
$fp = fopen("/tmp/lock.txt", "w+");
if (flock($fp, LOCK_EX)) { // pose un verrou exclusif
    fwrite($fp, "Écrire dans un fichier\n");
    flock($fp, LOCK_UN); // libère le verrou
} else {
    echo "Impossible de verrouiller le fichier !";
}
fclose($fp);
?>

Manipulation de fichiers

Pour copier un fichier on utilise la fonction copy(). Dans ce cas on se retrouve avec deux fichiers identiques.

Si vous voulez déplacer un fichier on emploie la fonction rename().

Dans les deux cas, le premier argument est l’adresse source, et le second argument est l’adresse destination.

<?php
copy("/css/template.css", "lyon/css/template.css");
?>

 Si le fichier de destination existe déjà, il sera écrasé.

Voici un exemple pour le déplacement d’un fichier.

<?php
rename("/css/template.css", "/css/style.css");
?>

Création d’un fichier

Vous pouvez aussi créer un fichier directement en utilisant la fonction touch(), pensez toutefois à vérifier l’existence du fichier avant de le créer.

<?php
$fichier = 'fantome.txt';
if(!file_exists($fichier)){
    touch($fichier);
}
?>

Suppression d’un fichier

Pour effacer un fichier , on utilise la fonction unlink() qui prend en argument le chemin du fichier. Pensez toutefois à vérifier l’existence du fichier avant de le supprimer.

<?php
if(file_exists($fichier)){
    unlink($fichier)
}
?>

Obtenir des fichiers temporaires

Il existe deux fonctions. La première est tmpfile() qui crée un fichier temporaire avec un nom unique, ouvert en écriture et lecture (w+), et retourne un pointeur de fichier.

Ce fichier sera automatiquement effacé lorsqu’il sera fermé (avec fclose()), ou lorsque le script sera terminé.

<?php
// création du fichier temporaire
$temp = tmpfile();
// écriture dans le fichier
fwrite($temp, "Écriture dans le fichier temporaire");
// replace le curseur à la position 0
fseek($temp, 0);
// lecture et affichage du fichier temporaire
echo fread($temp, 1024);
// fermeture du fichier
fclose($temp); // ceci va effacer le fichier
?>

La seconde fonction est tempnam(), qui crée un fichier dont le nom est unique, ayant comme permissions d’accès 0600, dans le dossier spécifié.

Si le dossier n’existe pas, tempnam() tentera de créer un fichier dans le dossier temporaire système, et retournera son nom. Vous pouvez ainsi manipuler le fichier sans qu’il soit effacé (par exemple le copier ou le déplacer par la suite), il vous appartient de le faire manuellement.

Le premier argument est le dossier temporaire, le deuxième est le préfixe du fichier.

<?php
// création d'un fichier
$tmpfname = tempnam("/tmp", "FOO");
// ouverture du fichier
$handle = fopen($tmpfname, "w");
// écriture dans le fichier
fwrite($handle, "Écriture dans le fichier temporaire");
// fermeture du fichier
fclose($handle);
// .... ici on pourrait l'utiliser, le copier..
//suppression du fichier
unlink($tmpfname);
?>

Parcourir un répertoire

Pour parcourir un répertoire il existe deux méthodes :

La méthode objet : dir() qui retourne une instance de la classe Directory.

<?php
// script permettant de récuperer tous les fichiers d'un répertoire
$d = dir("/etc/php5"); // création de l'objet $d
// lecture des fichiers par read()
while (false !== ($entry = $d->read())) {
   echo $entry . "\n";
}
$d->close();
?>

La méthode procédurale : opendir() pour ouvrir le répertoire, readdir() pour la lecture du contenu, filetype() retourne le type de fichier (dossier, fichier).

<?php
$dir = "/tmp/php5";
// Ouvre un dossier bien connu, et liste tous les fichiers
if (is_dir($dir)) { // si le dossier existe
    if ($dh = opendir($dir)) { // on ouvre le répertoire
        while (($file = readdir($dh)) !== false) { // tant qu'on peut lire
            echo "fichier : $file : type : " . filetype($dir . $file) . "\n"; // on affiche les fichiers
        }
        closedir($dh);
    }
}
?>

Filtrer un répertoire

La fonction glob() permet de récupérer tous les fichiers d’un répertoire correspondant à un masque(tous les .jpg, par exemple).

<?php
//ici, on va sélectionner tous les fichiers jpg
$fichier = glob('./*.jpg');
print_r($fichier);
?>

Position dans l’arborescence

Pour connaitre le répertoire courant, on utilise la fonction getcwd().

<?php
// dossier courant
echo getcwd() . "\n"; // affiche le dossier courant (ex : /photos)
?>

Pour changer le répertoire courant on utilise la fonction chdir().

<?php
// affiche le dossier courant
echo getcwd() . "\n"; // affichera  /photos
// on change le dossier courant
chdir('vacances');
// affiche à nouveau le dossier courant
echo getcwd() . "\n"; // affichera /photos/vacances
?>

Création et effacement de répertoire

Il existe des fonctions spécifiques pour créer et supprimer les répertoires : mkdir() permet la création et rmdir() l’effacement.

<?php
// création du répertoire
if (!is_dir('examples')) {
    mkdir('examples');
}
// effacement
rmdir('examples');
?>

Information sur les fichiers

La fonction file_exists() permet de vérifier si un fichier ou un dossier ou un lien existe.

<?php
$filename = '/path/to/foo.txt';
if (file_exists($filename)) {
    echo "Le fichier $filename existe.";
} else {
    echo "Le fichier $filename n'existe pas.";
}
?>

La fonction is_file() indique si le fichier est un véritable fichier

<?php
var_dump(is_file('plage.jpg')); // affiche bool(true)
var_dump(is_file('/images/vacances/')); // affiche bool(false)
?>

Pour obtenir la date de création d’un fichier, on utilise filectime().

Une autre fonction utile est filemtime() qui lit la date à laquelle le fichier a été modifié pour la dernière fois.

<?php
// Affichera : somefile.txt a été modifié le : December 29 2002 22:16:23.
$filename = 'somefile.txt';
if (file_exists($filename)) {
    echo "$filename a été modifié le : " . date ("F d Y H:i:s.", filemtime($filename));
}
?>

Pour afficher la date du dernier accès : fileatime(). La fonction renvoie la date à laquelle le fichier a été accédé pour la dernière fois.

Une fonction déjà rencontrée est filesize(), avec l’adresse du fichier en argument, et qui sert à récupérer la taille du fichier.

Pour récupérer d’autres types d’infos, vous pouvez utilisez la fonction stat() qui renvoie les informations à propos d’un fichier dans un tableau associatif. Elle prend en argument une adresse de fichier.

Les differents indices et leurs significations sont :

•  dev : volume
•  nlink : nombre de liens
•  size : taille en octets
•  atime : date de dernier accès (Unix timestamp)
•  mtime : date de dernière modification (Unix timestamp)
•  ctime : date de dernier changement d’inode (Unix timestamp)

<?php
// Récupération des informations
$stat = stat('C:\php\php.exe');
// Affichage de la date et heure de l'accès à ce fichier,
echo 'Date et heure d\'accès : ' . $stat['atime'];
// Affiche de la date et heure de modification du fichier,
echo 'Date et heure de modification : ' . $stat['mtime'];
?>

Pour récupérer l’adresse absolue d’un fichier : realpath() qui permet de connaitre le chemin réel d’un fichier. Une adresse relative sera transformée en adresse absolue.

<?php
echo realpath('/windows/system32'); // affiche C:\WINDOWS\System32
?>

Pour récupérer l’adresse d’un répertoire parent à partir du fichier : dirname() qui retourne le nom du dossier parent. S’il n’y a pas de slash dans le chemin path, un point (‘.’) sera retourné, indiquant le dossier courant.

<?php
$path = "/etc/passwd";
$file = dirname($path); // $file vaut "/etc"
?>

Attention à dirname(), qui ne sait traiter qu’une adresse absolue (pensez donc à utiliser realpath() avant).

Pour retourner des informations sur un chemin système : pathinfo() retourne un tableau associatif, contenant les informations sur le chemin path . Les éléments suivants sont retournés : dirname, basename, filename et extension .

<?php
$path_parts = pathinfo('/www/htdocs/index.php');
 
echo $path_parts['dirname']; // affichera /www/htdocs
echo $path_parts['basename']; // affichera index.php
echo $path_parts['extension']; // affichera php
echo $path_parts['filename']; // affichera index
?>