Classe PHP5 : File Handling

Description

Cette classe PHP5 a une orientation POO ; elle montre comment utiliser la bibliothèque standard SPL, en rapport avec la gestion de fichiers.

Dans le contexte de cette classe, qui n'est pas finalisée, loin s'en faut, on utilise principalement les classes SplFileInfo, et SplFileObject - cette dernière étant un héritage de la première -.

Utilisation de la classe File_handling

Comment utiliser cette fichue classe ?
Là, est la question !

Cette classe est assez simple à utiliser :

// Dans un premier temps, on déclare la classe :
$handling = new file_handling();

// Ensuite, on s'assure que le fichier appelé existe, avant de continuer tout traitement dessus !
if($handling->verif_file($file)) {
        bloc_instructions;
}

// Si on veut lire un fichier, il y a deux manières :
=> Obtenir le contenu du fichier dans une variable string
$str = $handling->file_infos($file, 'file_get_contents');

=> Obtenir le contenu du fichier dans un array, chaque ligne étant la valeur correspondante à une clé...
$array = $handling->file_object($file, 'fgets');

// Si on veut écrire un fichier, il y a deux méthodes :       // voir la note *1*, ci-dessous !
=> avec les modes 'w', 'w+', 'wb'
$handling->file_infos($file, 'write', 'w', $ressource);
=> avec les modes 'a', 'a+', 'ab'
$handling->file_object($file, 'write', 'a', $ressource);

// Si on veut obtenir des informations équivalentes à la function 'finfo' :
=> les modes utilisables sont 'mime', 'mime_encoding', 'mime_type'
$mime = $handling->file_infos($file, 'finfo', 'mime_type');     // pour l'exemple, retourne le type MIME du fichier

// Si on veut obtenir des informations équivalentes à la function 'pathinfo' :
=> les modes utilisables sont 'base', 'dir', 'ext', 'name'
$info = $handling->file_infos($file, 'pathinfo', 'ext');        // pour l'exemple, retourne l'extension du fichier
 

 

*1* : Bien que la classe SplFileObject puisse écrire un fichier, avec sa méthode fwrite(), elle n'est pas capable de le créer d'abord ...
Pour cela, il faut utiliser la classe mère SplFileInfo, et sa propre méthode fwrite() !
C'est la raison pour laquelle, concernant cette classe file_handling, on utilise la méthode file_infos() avec les modes 'w', puis la méthode file_object() avec les modes 'a' ...

 

File_handling :: Code source

 

Voici le code source de la classe "manageFile".

<?php
/***
 * class PHP display_message : to display message in class odt2xhtml
 * Copyright (C) 2011  Stephane HUC
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Contact information:
 *   Stephane HUC
 *   <devs@stephane-huc.net>
 *
 ***/

 
/***
 *
 * Use the class:
 *
 * $this->file = new file_handling();
 *
 * if($this->file->verif_file($file)) $this->file->file_object($file);
 *
***/

class file_handling {

       
       
        public function __construct() {
        }
       
        public function __destruct() {         
        }
       
        public function dir_object($path) {
                try {
                       
                        $this->it = new DirectoryIterator($path);
                       
                        return $this->it;
                       
                }
                catch(Exception $e) { die('Error_method: '.__METHOD__.' '.$e->getMessage()); }
        }
       
        /*** obtain file info ***/
        public function file_infos($file, $info, $mode='', $resource='') {
                try {
                       
                        if(!empty($info) && is_string($info)) {
                                switch($info) {
                               
                                        case 'file_get_contents':
                                                return file_get_contents($file);
                                        break;
                               
                                        case 'finfo':
                                                if(!empty($mode) && is_string($mode)) {
                                                        switch($mode) {
                                               
                                                                case 'mime':
                                                                        $this->finfo = finfo_open(FILEINFO_MIME);
                                                                break;
                                               
                                                                case 'mime_encoding':
                                                                        $this->finfo = finfo_open(FILEINFO_MIME_ENCODING);
                                                                break;
                                                               
                                                                case 'mime_type':
                                                                        $this->finfo = finfo_open(FILEINFO_MIME_TYPE);
                                                                break;
                                                               
                                                        }
                                                       
                                                        if(!empty($this->finfo)) {
                                                                $this->mime = finfo_file($this->finfo, $file);
                                                                finfo_close($this->finfo);
                                                        }
                                                       
                                                        if(!empty($this->mime)) return $this->mime;
                                                }
                                        break;
                               
                                        case 'pathinfo':
                                                $this->pathinfo = pathinfo($file);
                                       
                                                if(!empty($mode) && is_string($mode)) {
                                                        switch($mode) {
                               
                                                                case 'base':    return $this->pathinfo['basename'];     break;
                                                       
                                                                case 'dir':     return $this->pathinfo['dirname'];      break;
                                               
                                                                case 'ext':     return $this->pathinfo['extension'];    break;
                                               
                                                                case 'name':    return $this->pathinfo['filename'];     break;
                                               
                                                                default:        return $this->pathinfo;         break;
                               
                                                        }
                                                }
                                        break;
                               
                                        case 'write':
                                                if( !$this->file->isFile() ||
                                                        $this->file->isFile() && $this->file->isWritable() ) {
                                                       
                                                        $handle = $this->file->openFile($mode);        
                                                        $handle->fwrite($resource);
                                                        //fclose($handle);

                                                }
                                        break;
                               
                                }
                       
                                unset($file);
                        }
                       
                }
                catch(Exception $e) { die('Error_method: '.__METHOD__.' '.$e->getMessage()); }
        }
       
        /*** obtain file content ***/
        public function file_object($file, $info='', $mode='', $resource='') {
                try {
                       
                        $this->file = new SplFileObject($file);
                               
                        switch($info) {
                               
                                case 'fgets':
                                        while(!$this->file->eof()) { $lines[] = trim($this->file->fgets()); }
                                        $this->lines = $lines;
                                        return $this->lines;
                                break;
                               
                                case 'write':
                                        if( $this->file->isFile() && $this->file->isWritable() ) {
                                                $handle = $this->file->openFile($mode);        
                                                $handle->fwrite($resource);
                                        }
                                break;
                               
                                default:
                                        return $this->file;
                                break;
                       
                        }
                       
                        unset($file);
                       
                }
                catch(Exception $e) { die('Error_method: '.__METHOD__.' '.$e->getMessage()); }
        }
               
        /*** verif file ***/
        public function verif_dir($file) {
                try {
                       
                        $this->file = new SplFileInfo($file);
                        if( !$this->file->isDir()
                                || ( $this->file->isDir() && !$this->file->isReadable() )
                                || ( $this->file->getOwner() != fileowner(__FILE__) ) )
                        {
                                return FALSE;
                        }
                        else return TRUE;
                       
                }
                catch(Exception $e) { die('Error_method: '.__METHOD__.$e->getMessage()); }
        }
       
        /*** verif file ***/
        public function verif_file($file) {
                try {
                       
                        $this->file = new SplFileInfo($file);
                        if( !$this->file->isFile()
                                || ( $this->file->isFile() && !$this->file->isReadable() )
                                || ( $this->file->getOwner() != fileowner(__FILE__) ) )
                        {
                                return FALSE;
                        }
                        else return TRUE;
                       
                }
                catch(Exception $e) { die('Error_method: '.__METHOD__.$e->getMessage()); }
        }
       
 }
?>
 

 

 


| Page : PHP : class : file_handling : |>>


 

 

^ Haut de page ^