Tout d'abord un petit rappel sur les fichiers ini. Ce sont des fichiers au format texte qui contiennent des sections et des propriétés auxquelles sont affectées des valeurs. Ils sont présentés de la façon suivante.

[SECTION]
prop_1 = valeur
prop_2 = valeur

La fonction parse_ini_file() créé un tableau contenant les valeurs d'un fichier ini. Il y a deux degrés de détail que l'on peut demander à la fonction. Pour l'exemple donné ci-dessus:

$ini = parse_ini_file("fichier.ini");

retournera le tableau suivant:

$ini["prop_1"] = valeur;
$ini["prop_2"] = valeur

Si l'on rajoute TRUE comme deuxième argument:

$ini = parse_ini_file("fichier.ini", TRUE);

Le tableau suivant sera retourné:

$ini["SECTION"]["prop_1"] = valeur
$ini["SECTION"]["prop_2"] = valeur

Un tableau à deux dimensions donc, ce qui est très utile dès lors que le fichier ini contient plus d'une section.

Par défaut, un PHP tournant sous Windows ou UNIX ne sait pas lire les fichiers MAC, et inversement (un PHP tournant sous MAC ne sait pas lire un fichier Windows ou UNIX correctement).
Le problème vient des sauts de ligne différents en fonction des systèmes : sous UNIX, par exemple, un fgets (ou fgetcsv) d'un fichier MAC retourne le fichier entier !

Pour éviter ce problème, il suffit juste d'activer l'option "auto_detect_line_endings" de php.ini (éventuellement via la fonction "ini_set()"). L'option est a priori désactivée par défaut (en tout cas pour PHP 4, dans php.ini-dist et php.ini-recommended).

Une autre solution est d'utiliser la constante PHP_EOLConstantes pré-définies en PHP.

Le type mime d'un fichier est le nom normalisé de son format.
Ainsi, une image GIF ou un document PDF sont des types de fichier bien différents. Leur type MIME respectif a une dénomination normalisée. Ce type est automatiquement détecté par le serveur lors d'un upload. Cette information est fournie par le tableau superglobal associatif $_FILES qui contient les informations sur les fichiers uploadés via un formulaire.

Exemple :

/* tableau des types mimes autorisés */
$mime_types = array('image/jpeg','image/gif','text/html','video/mpeg','application/postscript');
/* informations sur le fichier uploadé */
$file = $_FILES('mon_fichier');
/* contrôle de son type mime */
if(in_array($file['type'], $mime_types)) {
    /* traitement du fichier */
    echo "ok";
} else {
    /* annulation */
    echo "pas ok";
}

Voici une petite liste de types MIME les plus courants :

• application/msword (fichier Word : doc, dot))
• application/msexcel (fichier Excel : xls)
• application/mspowerpoint (fichier PowerPoint : ppt, ppz, pps, pot)
• application/octet-stream (fichier binaire non interpété : exe)
• application/pdf (fichier Adobe Acrobat : pdf)
• application/postscript (fichier PostScript : ai, eps, ps)
• application/x-dvi (fichier DVI : dvi)
• application/x-latex (fichier Latex : tex)
• application/x-tar (fichier compressé TAR : tar)
• application/zip (fichier compressé ZIP : zip)
• audio/x-pn-realaudio (fichier RealAudio : ram, ra)
• audio/x-midi (fichier MIDI : mid, midi)
• audio/x-wav (fichier audio Wave : wav)
• image/gif (fichier image GIF : gif)
• image/jpeg (fichier image Jpeg : jpg, jpeg)
• image/png (fichier image PNG : png)
• image/tiff (fichier image TIFF : tif, tiff)
• image/gif (fichier image GIF : gif)
• text/html (fichier texte HTML : html, htm)
• text/plain (fichier texte sans mise en forme : txt, c, h)
• text/javascript (fichier JavaScript : js)
• text/css (fichier Feuille de Style CSS : css)
• text/comma-separated-values (fichier de données séparées par des virgules : csv)
• video/mpeg (fichier vidéo Mpeg : mpg, mpeg)
• video/quicktime (fichier vidéo QuickTime : gt, mov)
• video/msvideo (fichier vidéo Microsoft Windows : avi)

Il arrive qu'un hébergeur désactive les fonctions file_get_contents() et file_put_contents. Dans ce cas, on peut surmonter cette défaillance en redéfinissant celles-ci de la manière suivante :

if(!function_exists('file_get_contents'))
{   
  function file_get_contents($filename)
  {
    if($fp = fopen($filename,'rb'))
    {
      $buffer = fread($fp,filesize($filename));
      fclose($fp);
      return $buffer;
    }
    else return false;
  }
}

Et

if(!function_exists('file_put_contents'))
{ 
  function file_put_contents($filename,$data)
  {
    if($fp = fopen($filename,'wb'))
    {
      $ok = fwrite($fp,$data);
      fclose($fp);
      return $ok;
    }
    else return false;
  }
}

$file = "monfichier.txt";
if(file_exists($file)) {
    $tab = file($file); 
    echo count($tab);
}

La fonction file() retourne le contenu du fichier sous la forme d'un tableau de lignes et la fonction count() décompte le nombre de lignes d'un tableau.

La fonction file_exists()Voir la fonction file_exists() dans le manuel PHP retourne TRUE si le fichier existe.

Le chemin passé en argument peut être partiel ("./fichier.txt") ou complet ("c:\dossier\fichier.txt" ou /dossier/fichier.txt selon le système) mais ne peut être qu'un chemin local ou une ressource réseau.
On ne peut donc pas fournir une adresse du type: "http://www.monsite.com/monfichier.txt".

On va lister les noms des fichiers du dossier et extraire leur date de dernière modification (timestamp Unix) avec filemtime(). Ces deux valeurs seront mise dans un tableau.

$path = '.';// Listage d'un répertoire $path
if ($dir = @opendir($path)) {// ouverture du dossier 
    while($file = readdir($dir)) { // lecture d'une entrée 
        //création d'un tableau à 2 colonnes : nom + date fichiers 
        $tab[] = array($file, filemtime($file));  
        // sauvegarde du nom du fichier et de sa date 
    }
    closedir($dir); // fermeture du dossier 
}

Puis, on va trier ce tableau sur les dates. Comme il n'existe pas de fonction triant directement notre tableau de tableaux, nous allons avoir recours à la fonction usort() qui permet de trier un tableau grâce à une fonction personnalisée, ici cmp(). Cette dernière fonction permet de comparer deux entrées du tableau. Ici elle va porter sur le deuxième élément (la date) du tableau que constitue une entrée du tableau. Notre fonction de comparaison doit retourner 0 si deux entrées sont égales, -1 si la première est inférieure à la deuxième, +1 sinon.

//tri du tableau sur les dates
function cmp($a,$b) {
    if ($a[1] == $b[1])
        return 0;
    return ($a[1] < $b[1]) ? -1 : 1;
}

usort($tab, "cmp");

Puis on va afficher notre tableau trié, en formatant la date pour qu'elle apparaissent en langage humain avec date().

echo "<table>";
foreach($tab as $elem) {
    //formatage de la date avec mktime() selon le format retourné par filemtime()
    echo "<tr><td>".$elem[0]."</td><td>".date("d-m-Y H:i:s",$elem[1])."</td></tr>"; 
}
echo "</table>";

Si une opération doit être faite sur toutes les lignes d'un fichier, la fonction file() va s'avérer très utile.

Cette fonction retourne le contenu d'un fichier dans un tableau, à raison d'une ligne par élément. Une fois le tableau construit, il est facile d'effectuer une boucle sur les éléments du tableau afin de leur appliquer le traitement souhaité.

Un fichier au format CSV est souvent utilisé pour exporter les données d'une feuille de calcul Excel, ou d'une base Access. Ensuite on peut réimporter ce fichier via PHP pour remplir une base MySQL.

Ainsi une ligne d'une table Excel ou Access est représentée par une ligne du fichier. Les champs étant délimités par un caractère spécial : \n, : ou autre... Les chaînes de caractères encadrées par des doubles quotes.

La fonction fgetcsv($pointeur, $taille) permet d'extraire une ligne de ce type de fichier. Elle fonctionne comme fgets(). Elle prend pour paramètres le pointeur sur le fichier obtenu par fopen(), ainsi que la taille limite de la ligne à lire. Elle retourne un tableau dont chaque élément est un champ de la ligne.

L'argument optionnel $delimiteur peut être ajouté. Il permet de spécifier le délimiteur de champs.

Exemple :

$file = "mon_fichier.csv";
$taille = 1024;
$delimiteur = ":";
/* ouverture en lecture */
if($fp = fopen($file,"r")) {
    /* extraction d'une ligne */
    while ($ligne = fgetcsv($fp, $taille, $delimiteur)) {
        /* affichage des champs */
        foreach($ligne as $elem) {
            echo "$elem<br/>";
        }
    }
    /* fermeture fichier */
    fclose ($fp);
} else {
    echo "Ouverture impossible.";
}

En lieu et place de fgetcsv(), on peut utiliser fgets(), puis explode($delimiteur,$ligne).

Exemple :

$file = "mon_fichier.csv";
$taille = 1024;
$delimiteur = ":";
/* ouverture en lecture */
if($fp = fopen($file,"r")) {
    /* extraction d'une ligne */
    while ($ligne = fgets($fp, $taille)) {
        /* extraction champs */
        $tab = explode($delimiteur, $ligne);
        /* affichage des champs */
        foreach($tab as $elem) {
            echo "$elem<br/>";
        }
    }
    /* fermeture fichier */
    fclose ($fp);
} else {
    echo "Ouverture impossible.";
}

On peut récupérer le contenu d'un fichier de deux manières différentes :

1. En utilisant la fonction file_get_contents() qui lit tout un fichier dans une chaîne (disponible à partir de PHP 4).
2. En utilisant les fonctions fopen(), fread() et fclose() qui permettent l'ouverture, la lecture et la fermeture du fichier.

• Récupération du contenu d'un fichier en local :

$contents = file_get_contents("mon_fichier.txt"); //Récupère tout le contenu du fichier et le place dans une chaîne de caractères

Ou

$fd = fopen( "mon_fichier.txt", "r" ); // Ouverture du fichier en lecture seule
$contents = fread( $fd, filesize( $filename ) ); //Récupère tout le contenu du fichier et le place dans une chaîne de caractères
fclose($fd); //Fermeture du fichier

Récupération du contenu d'un fichier en ligne :

$contents = file_get_contents("url du fichier");

Ou

$fd = fopen($url, 'r'); // Ouverture du fichier en lecture seule
while(!eof($fd))
{
  $contents .= fread($fd, 8192); //Récupère tout le contenu du fichier et le place dans une chaîne de caractères
}
fclose($fd); //Fermeture du fichier

PS : Il n'est possible de récupérer un fichier par son URI complète que si la directive allow_url_fopen est activée dans le php.ini.

PHP dispose pour cela de la fonction is_dir() dont le prototype est le suivant :

boolean is_dir(string filename)

Elle renvoie la valeur TRUE si filename existe et est un dossier, FALSE dans le cas contraire.

Cette fonction ne marche qu'avec les fichiers qui sont accessibles par le système de fichier du serveur. Vous ne pouvez donc pas l'utiliser pour tester l'existence de fichiers distants.

function tri_lexicographique($chemin) {
    // Création du tableau qui va contenir les fichiers et dossiers
    $fichiers = array();
 
    // Quoiqu'il arrive on transpose le chemin fournit en un chemin absolu "passe-partout"
    $chemin = realpath($chemin) . DIRECTORY_SEPARATOR;
 
    if (is_dir($chemin)) {
 
        // Ouverture du répetoire courant
        $handle = opendir($chemin);
 
        // Parcours des fichiers et dossiers du répertoire courant
        while (($f = readdir($handle)) !== FALSE) {
            if ($f != '.' && $f != '..') {
                array_push($fichiers, $f);
            }
        }
 
        // Fermeture du répertoire courant
        closedir($handle);
 
        // Tri du tableau
        natsort($fichiers);
    }
 
    return $fichiers;
}
 
// Affichage des fichiers et dossiers triés du répertoire courant
foreach(tri_lexicographique('.') as $f) {
    echo $f . '<br />';
}

Il suffit d'ajouter les fichiers et les dossiers au fur et à mesure dans un tableau puis de le trier et enfin de le parcourir pour affichage ou autre.

Pour savoir si un dossier est vide, on peut utiliser les fonctions :

• glob() qui retourne un tableau contenant les chemins et fichiers trouvés
• scandir() qui retourne un tableau de fichiers et dossiers

Exemple 1 :

$dossier = "test/";
if(glob($dossier."*")) 
{
  echo "Dossier n'est pas vide";
}

Exemple 2 :

$dossier = "test";
if(sizeof(scandir($dossier))>2)
{
  echo "Le dossier n'est pas vide";
}
else
{
  echo "Le dossier est vide";
}

Il n'est pas possible pour des raisons évidentes de sécurité de faire ce genre d'opération. PHP s'exécute côté serveur et rien ne peut être tenté côte client sans son accord.