SimpleFiles

SimpleFiles est une classe php qui permet de faciliter l'utilisation des fichiers.

Grâce à cette classe l'utilisation des fichiers est aussi simple que l'utilisation d'une base de donnée avec le language sql.

Voici les fonctions principales de la classe :

* Lire certaines lignes d'un fichier "à la select" de mysql :
o Utilisation de WHERE sous toutes ses formes.
o Utilisation de ORDER BY.
o Utilisation de LIMIT.
* Ajouter des lignes dans un fichier.
* Modifier certaines lignes d'un fichier (avec WHERE).
* Supprimer ceraines lignes dans un fichier.
* Backup automatique off/on.
* Verrou automatique off/on
* Cryptage/décryptage (fonction utilisateur ou par défaut dans la classe) de certains champs automatique off/on.
* Hashage (md5/sha1) automatique de certains champs off/on.
* Utilisation de fichier dit "utilisateur" (pour y mettre des compteurs par exemple)

Tous les codes

Oprichnik

Code vu 4792 fois

Enregistré le 13 Aout 2007

téléchargement du zip

impression de la fiche

Code Source

<?php
/******************************************************************************/
/*                                                                            */
/*                       __        ____                                       */
/*                 ___  / /  ___  / __/__  __ _____________ ___               */
/*                / _ \/ _ \/ _ \_\ \/ _ \/ // / __/ __/ -_|_-<               */
/*               / .__/_//_/ .__/___/\___/\_,_/_/  \__/\__/___/               */
/*              /_/       /_/                                                 */
/*                                                                            */
/*                                                                            */
/******************************************************************************/
/*                                                                            */
/* Titre          : SimpleFiles                                               */
/*                                                                            */
/* URL            : http://www.phpsources.org/scripts294-PHP.htm              */
/* Auteur         : Oprichnik                                                 */
/* Date édition   : 13 Aout 2007                                              */
/*                                                                            */
/******************************************************************************/

/***********************************************************
 * Auteur : Mallory Dessaintes
 * Email de l'auteur : mallory.dessaintes@gmail.com 
 * Site Web : http://oprichnik.monespace.be
 *
 * Documentation : "documentation.html"
 *
 *
 * VERSION : [1.0]
 *
 *
 ***********************************************************/

class simplefiles {
  
  private $read_default_return_structure;
  private $lastId;
  private $flock_on;
  
  private $backup_on;
  private $backup_dir;
  private $backup_time;
  
  private $hash_on;
  private $hash_fields;
  private $hash_type;
  
  private $crypt_on;
  private $crypt_fields;
  private $crypt_password;
  private $crypt_functions;
  
  private $select_a_u_fichier;
  private $select_a_read;
  private $select_last_id;
  
  // ---------------------------------------------------------------
  
  function __construct() {
    $this->read_default_return_structure = 2;
    $this->flock_on = true;
    $this->backup_on = false;
    $this->crypt_on = false;
    $this->hash_on = false;
    $this->select_a_read = false;
    $this->select_last_id = false;
  }
  
  // ---------------------------------------------------------------
  
  private function is_assoc_array($array) {
      if(!is_array($array))
        return false;
      
       $next = 0;
       foreach ($array as $k=>$v) {
         if ($k === $next)
           return false;
         $next++;
       }
       return true;
  }
  
  private function is_assoc_multi_array($array) {
      foreach($array as $k => $valeur) {
      if(!$this->is_assoc_array($valeur))
      return false;
      }
      
      return true;
  }
  
  private function sort_by_key($array, $index) {
    $sort = array();
    //préparation d'un nouveau tableau basé sur la clé à trier
    foreach ($array as $key => $val) {
      $sort[$key] = $val[$index];
    }
    
    asort($sort);
    //formation du nouveau tableau trié selon la clé
    $output = array();
    foreach($sort as $key => $val) {
      $output[] = $array[$key];
      
    }
    return $output;
  }
  
  private function str_decode($str,$filter) {
     $filter = md5($filter);
     $letter = -1;
     $newstr = '';
     $str = base64_decode($str);
     $strlen = strlen($str);

for ( $i = 0; $i < $strlen; $i++ )
     {
      $letter++;

if ( $letter > 31 )
      {
       $letter = 0;
      }

$neword = ord($str{$i}) - ord($filter{$letter});

if ( $neword < 1 )
      {
       $neword += 256;
      }
      
      $newstr .= chr($neword);
     }

return $newstr;
  }

private function str_encode($str,$filter) {
     $filter = md5($filter);
     $letter = -1;
     $newpass = '';

$strlen = strlen($str);
     
     for ( $i = 0; $i < $strlen; $i++ )
     {
      $letter++;

if ( $letter > 31 )
      {
       $letter = 0;
      }

$neword = ord($str{$i}) + ord($filter{$letter});

if ( $neword > 255 )
      {
       $neword -= 256;
      }

$newstr .= chr($neword);

}
     
     return base64_encode($newstr);
  }
  
  private function cryptAndHashTest($array) { // tableau unidimensionnel
    $result = $array;
    
    foreach($array as $cle => $valeur) {
        if($this->hash_on == true && in_array($cle,$this->hash_fields)
           or $this->hash_fields[0] == "*")
          ($this->hash_type == "sha1")?$result[$cle] =
                            sha1($valeur):$result[$cle] = md5($valeur);
        if($this->crypt_on == true && in_array($cle,$this->crypt_fields)
           or $this->crypt_fields[0] == "*") {
          if($this->crypt_functions)
            $result[$cle] = call_user_func($this->crypt_functions[0],
            $result[$cle],$this->crypt_password);
            // Je modifie $result[$cle] et non pas $valeur comme au dessus
            // car si le script a hashé dans le script du dessus et qu'il doit
            // être crypté en dessous cela ne marchera pas en reprenant la
            // valeur du tableau d'argument
          else
            $result[$cle] = $this->str_encode($result[$cle],
            $this->crypt_password);
        }

}
    return $result;
  }
  
  private function decryptTest($array) { // array[][]
    $result = $array;
    
    foreach($array as $cle => $valeur) {
      foreach($valeur as $cle2 => $valeur2) {
          if($this->crypt_on == true && in_array($cle2,$this->crypt_fields)
              or $this->crypt_fields[0] == "*") {
            if($this->crypt_functions)
              $result[$cle][$cle2] = call_user_func($this->crypt_functions[1],
              $valeur2,$this->crypt_password);
            else
              $result[$cle][$cle2] = $this->str_decode($valeur2,
              $this->crypt_password);
          }
      }
    }
    return $result;
  }
  
  private function backupTest($u_fichier) {
    if($this->backup_on) {
    $pathInf = pathinfo($u_fichier);

$last_num_backup = 0;
    
    while(file_exists($this->backup_dir.$pathInf["filename"]."_
         ".$last_num_backup.".backup"))
      $last_num_backup++;
      
    if(!file_exists($this->backup_dir.$pathInf["filename"]."_0.backup"))
      $filemtime = 0;
    else
      $filemtime = filemtime($this->backup_dir.$pathInf["filename"]."_
      ".($last_num_backup-1).".backup");

if(file_exists($u_fichier) && (time() - $filemtime > $this->backup_time))
      copy($u_fichier,$this->backup_dir.$pathInf["filename"]."_
      ".$last_num_backup.".backup");
    }
  }
  
  // ---------------------------------------------------------------
  
  public function escapeQuotes($str) {
    if(get_magic_quotes_gpc())
      $str = stripslashes($str);
    
    $str = str_replace('\\','\\\\',$str);
    $str = str_replace("'","\\'",$str);
    
    return $str;
  }
  
  public function escape2Quotes($str) {
    if(get_magic_quotes_gpc())
      $str = stripslashes($str);
    
    $str = str_replace('\\','\\\\',$str);
    $str = str_replace('"','\\"',$str);
    
    return $str;
  }
  
  public function setReadDrs($i_s) { // default return structure
    if($i_s == 1 or $i_s == 2 or $i_s == 3 or $i_s == 4)
      { // 1 vecteur 2 associatif 3 les deux 4 like file
      $this->read_default_return_structure = $i_s;
      return true;
    }
    else
      return false;
  }
  
  public function setFlock($status) {
    if($status)
      $this->$flock_on = true;
    else
      $this->$flock_on = false;
      
    return true;
  }
  
  public function setBackup($status,$dir = false,$time = 86400) {
    if($status == true) {
      if(ctype_digit($time) == true) {
        $this->backup_on = true;
        
        if($dir[strlen($dir)-1] != "/")
          $dir .= "/";
        
        $this->backup_dir = $dir;
      }
      else
        return false;
    }
    else
      $this->backup_on = false;
  
    return true;
  }
  
  public function setHash($status,$fields = false,$type = false) {
  // fields séparés par des "," type = "md5" ou "sha1"
    if($status && $fields && $type) {
      $this->hash_on = true;
      $this->hash_fields = explode(",",$fields);
      $this->hash_type = $type;
    }
    else
      $this->hash_on = false;
      
    return true;
  }
  
  public function setCrypt($status,$fields = false,$password = false) {
  // fields séparés par des ","
    if($status && $fields && $password) {
      $this->crypt_on = true;
      $this->crypt_fields = explode(",",$fields);
      $this->crypt_password = $password;
    }
    else
      $this->crypt_on = false;
      
    return true;
  }
  
  public function setCryptFunctions($CryptFctName,$DecryptFctName) {
    if(function_exists($CryptFctName) && function_exists($DecryptFctName)) {
      $this->crypt_function[0] = $CryptFctName;
      $this->crypt_function[1] = $DecryptFctName;
      
      return true;
    }
    else
      return false;
  }
  
  public function getLastId() {
    return $this->lastId;
  }
  
  public function unik() { 
    $ttime = str_replace(".","",time() + microtime(true)); // total time
    echo $ttime."<br />";
    $a_ttime = str_split($ttime);
    $ar_ttime = array_reverse($a_ttime);
    
    $result = "";
    $chars = array("a","b","c","d","e","f","g","h","i","j","k","l","m",
                   "n","o","p","q","r","s","t","u","v","w","x","y","z",
    "A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q",
    "R","S","T","U","V","W","X","Y","Z");
    for($i=0;$i<count($ar_ttime);$i++) {
      $result .= $chars[mt_rand(0,count($chars)-1)].$ar_ttime[$i];
    }
    return $result;
  }
  
  public function valueExist($value,$field,$haystack,$caseSensitive = true) {
  
    if($caseSensitive)
      $value = strtolower($value);
  
    if(!is_array($haystack)) {
      require($haystack);
      $haystack = $FILE;
    }
  
    foreach($haystack as $line) {
      if($caseSensitive)
        $line[$field] = strtolower($line[$field]);
        
        if($line[$field] == $value)
          return true;
    }
    return false;
  }
  
  public function read($u_fichier,$where = false,$orderBy = false,
  $limit = false,$i_return_structure = false)
  { # Ancienne structure where = "pseudo='oprichn,ik',
   'dracau'&email='mallory.dessaintes@gmail.com'"

if(!file_exists($u_fichier))
      return false;
    if(!isset($FILE_LAST_ID))
      $FILE_LAST_ID = 0;
    
    require($u_fichier);
    
    if(!isset($FILE))
      return array(); // Il n'y a rien à retourner
    elseif(!$this->is_assoc_multi_array($FILE))
      return false;
    elseif($this->crypt_on)
      $FILE = $this->decryptTest($FILE);
    
    if($where) {
      if(!is_array($where)) {
      
        $result = array();
        
        foreach($FILE as $k => $valeur) {
        // On parcourt le fichier pour trouver les lignes à retourner
          $LINE = $valeur;
          $eval = "if($where) { $result[] = $valeur; }";
          ob_start(); // Securité pour ne rien afficher à l'écran
          eval($eval);
          ob_clean();
        }
        
      }
      else {
      
        $a_where = $where;
      
        $result = array();
        
        foreach($FILE as $cle => $valeur) {
        // On parcourt le fichier pour trouver les lignes à retourner
          $i2 = 0;
          foreach($a_where as $cle2 => $valeur2) {
          // On parcourt le tableau where à chaque ligne du fichier
          //pour voir si il correspond avec where
            if(is_array($valeur2)) {
              if(in_array($valeur[$cle2],$valeur2))
              $result[] = $valeur;
            }
            else {
              if($valeur[$cle2] == $valeur2)
              $result[] = $valeur;
            }
          }
        }
      }
    }
    else
      $result = $FILE;
    
    // On modifie le tableau en fonction du paramètre orderBy
    
    if($orderBy) {
      if(strtolower($orderBy) == "desc")
        $result = array_reverse($result);
      else {
        list($orderBy_champ,$orderBy_asc_dsc) = explode(" ",$orderBy);

$result = $this->sort_by_key($result,$orderBy_champ);
        
        if(strtolower($orderBy_asc_dsc) == "desc")
          $result = array_reverse($result);
        
      }
    }
      
    // On modifie le tableau en fonction du paramètre limit
    
    if($limit) { // Structure : $limit = "0-5" =>
                  //On prend les 5 premiers ou $limit = "5"
      $tmp_result = array();
      if(strpos($limit,"-") !== false) {
        $a_limit = explode("-",$limit);
        for($i=$a_limit[0];$i<min($a_limit[0]+$a_limit[1],count($result));$i++)
         {
          $tmp_result[$i] = $result[$i];
        }
      }
      else {
        for($i=0;$i<min($limit,count($result));$i++) {
          $tmp_result[$i] = $result[$i];
        }
      }
      $result = $tmp_result;
    }
  
    // On retourne un tableau selon le paramètre de retour (type de tableau)
    
    if(!$i_return_structure) 
      $i_return_structure = $this->read_default_return_structure;
    
    if($i_return_structure == 1) {
      $result2 = array(); $i = 0;
      foreach($result as $valeur) {
        foreach($valeur as $valeur2) {
          $result2[$i][] = $valeur2;
        }
        $i++;
      }
      return $result2;
    }
    elseif($i_return_structure == 3) {
      $result2 = array(); $i = 0;
      foreach($result as $valeur) {
        foreach($valeur as $cle => $valeur2) {
          $result2[$i][] = $valeur2;
          $result2[$i][$cle] = $valeur2;
        }
        $i++;
      }
      return $result2;
    }
    elseif($i_return_structure == 4) {
      $result2 = array(); $i = 0;
      foreach($result as $valeur) {
        foreach($valeur as $cle => $valeur2) {
          $result2[$i] = $valeur2;
          $i++;
        }
      }
      return $result2;
    }
    else
      return $result;
      
    // ---------------------------------------------------------------
  }
  
  public function readArrayLikeFile($FILE,$where = false,$orderBy = false,
  $limit = false,$i_return_structure = false) {
  # Ancienne structure where = "pseudo='oprichn,ik',
  'dracau'&email='mallory.dessaintes@gmail.com'"
    
    if(!isset($FILE))
      return array(); // Il n'y a rien à retourner
    elseif(!$this->is_assoc_multi_array($FILE))
      return false;
    
    if($where) {
      if(!is_array($where)) {
      
        $result = array();
        
        foreach($FILE as $k => $valeur) {
        // On parcourt le fichier pour trouver les lignes à retourner
          $LINE = $valeur;
          $eval = "if($where) { \$result[] = \$valeur; }";
          ob_start(); // Securité pour ne rien afficher à l'écran
          eval($eval);
          ob_clean();
        }
        
      }
      else {
      
        $a_where = $where;
      
        $result = array();
        
        foreach($FILE as $cle => $valeur) {
        // On parcourt le fichier pour trouver les lignes à retourner
          $i2 = 0;
          foreach($a_where as $cle2 => $valeur2) {
          // On parcourt le tableau where à chaque ligne du fichier
          //pour voir si il correspond avec where
            if(is_array($valeur2)) {
              if(in_array($valeur[$cle2],$valeur2))
              $result[] = $valeur;
            }
            else {
              if($valeur[$cle2] == $valeur2)
              $result[] = $valeur;
            }
          }
        }
      }
    }
    else
      $result = $FILE;
    
    // On modifie le tableau en fonction du paramètre orderBy
    
    if($orderBy) {
      if(strtolower($orderBy) == "desc")
        $result = array_reverse($result);
      else {
        list($orderBy_champ,$orderBy_asc_dsc) = explode(" ",$orderBy);

$result = $this->sort_by_key($result,$orderBy_champ);
        
        if(strtolower($orderBy_asc_dsc) == "desc")
          $result = array_reverse($result);
        
      }
    }
      
    // On modifie le tableau en fonction du paramètre limit
    
    if($limit) { // Structure : $limit = "0-5" =>
                  // On prend les 5 premiers ou $limit = "5"
      $tmp_result = array();
      if(strpos($limit,"-") !== false) {
        $a_limit = explode("-",$limit);
        for($i=$a_limit[0];$i<min($a_limit[0]+$a_limit[1],count($result));$i++)
         {
          $tmp_result[$i] = $result[$i];
        }
      }
      else {
        for($i=0;$i<min($limit,count($result));$i++) {
          $tmp_result[$i] = $result[$i];
        }
      }
      $result = $tmp_result;
    }
  
    // On retourne un tableau selon le paramètre de retour (type de tableau)
    
    if(!$i_return_structure) 
      $i_return_structure = $this->read_default_return_structure;
    
    if($i_return_structure == 1) {
      $result2 = array(); $i = 0;
      foreach($result as $valeur) {
        foreach($valeur as $valeur2) {
          $result2[$i][] = $valeur2;
        }
        $i++;
      }
      return $result2;
    }
    elseif($i_return_structure == 3) {
      $result2 = array(); $i = 0;
      foreach($result as $valeur) {
        foreach($valeur as $cle => $valeur2) {
          $result2[$i][] = $valeur2;
          $result2[$i][$cle] = $valeur2;
        }
        $i++;
      }
      return $result2;
    }
    elseif($i_return_structure == 4) {
      $result2 = array(); $i = 0;
      foreach($result as $valeur) {
        foreach($valeur as $cle => $valeur2) {
          $result2[$i] = $valeur2;
          $i++;
        }
      }
      return $result2;
    }
    else
      return $result;
      
    // ---------------------------------------------------------------
  }
  
  public function add($u_fichier,$a_add) {
    // Si une seule ligne à insérer
    if(!isset($a_add[0]))
    // Car les indices du tableau sont indexés associativement
      $__result[0] = $a_add;
    else
      $__result = $a_add;
  
    if(file_exists($u_fichier)) {
      require($u_fichier);
      
      if(!isset($FILE_LAST_ID))
        $FILE_LAST_ID = 0;
      elseif(isset($FILE) && !$this->is_assoc_multi_array($FILE))
        return false;
    }
    else
      $FILE_LAST_ID = 0;
      
    $i = 0;
    
    $_result = $__result;
      
    foreach($__result as $cle => $valeur) {
      foreach($valeur as $cle2 => $valeur2) {
        if($cle2 == "ID")
        // Si un champ a pour nom ID, sa valeur est
        // automatisée et correspond au numéro d'entrée
          $_result[$i][$cle2] = ++$FILE_LAST_ID;
      }
      
      // CRYPTAGE ET HACHAGE -------------------------------------------
      
      if($this->crypt_on or $this->hash_on)
        $_result[$i] = $this->cryptAndHashTest($valeur);
      $i++;
      
      // ---------------------------------------------------------------
    }
    
    $this->lastId = $FILE_LAST_ID;
    
    if(isset($FILE)) // Si le fichier existait déjà et qu'il n'est pas vide
      $result = array_merge($FILE,$_result);
    else
      $result = $_result;
      
    // FLOCK ---------------------------------------------------------
    
    $pathInf = pathinfo($u_fichier);
    $flockFilename = $pathInf["dirname"]."/".$pathInf["filename"].".flock";
    
    if($this->flock_on) {
      touch($flockFilename);
      $ffo = fopen($flockFilename,"r"); // File flock open
      flock($ffo,LOCK_EX);
    }
    else
      if(file_exists($flockFilename)) // Pour éviter les fichiers inutiles
        unlink($flockFilename);
    
    // ---------------------------------------------------------------
    
    // BACKUP --------------------------------------------------------
    
    $this->backupTest($u_fichier);
    
    // ---------------------------------------------------------------

$fo = fopen($u_fichier,"w");

fputs($fo,"<?php \n\$FILE_LAST_ID = $FILE_LAST_ID;\n\n");
    
    $i = 0;
    foreach($result as $cle => $valeur) {
        foreach($valeur as $cle2 => $valeur2) {
              fputs($fo,"\$FILE[$i][\"".$cle2."\"] =
                stripslashes(\"".addslashes($valeur2)."\");\n");
        }
        $i++;
    }
    
    fputs($fo,"?>");
    
    fclose($fo);
    
    // FLOCK ---------------------------------------------------------
    
    if($this->flock_on) {
      flock($ffo,LOCK_UN);
      fclose($ffo);
    }
    
    // ---------------------------------------------------------------
    
    return true;
  }

public function mod($u_fichier,$where,$a_mod) {
  // $a_mod est un tableau d'une dimension associatif
    if(!file_exists($u_fichier))
      return false;
    
    require($u_fichier);
    
    if(!isset($FILE_LAST_ID))
      $FILE_LAST_ID = 0;
    
    if(!isset($FILE))
      return false; // Il n'y a rien à retourner
    elseif(!$this->is_assoc_multi_array($FILE))
      return false;
    elseif($this->crypt_on)
      $FILE = $this->decryptTest($FILE);
    
    // CRYPTAGE ET HACHAGE -------------------------------------------
    
    if($this->crypt_on or $this->hash_on)
      $a_mod = $this->cryptAndHashTest($a_mod);
    
    // ---------------------------------------------------------------
    
    if($where) {
      if(!is_array($where)) {
        
        $result = $FILE;
        
        foreach($FILE as $k => $valeur) {
         // On parcourt le fichier pour trouver les lignes à retourner
          $LINE = $valeur;
          $eval = "if($where) { \$result[\$k] = array_merge(\$result[\$k],\$a_mod); }";
          ob_start(); // Securité pour ne rien afficher à l'écran
          eval($eval);
          ob_clean();
        }
      }
      else {
      
        $a_where = $where;
      
        $result = $FILE;
        
        foreach($FILE as $cle => $valeur) {
        // On parcourt le fichier pour trouver les lignes à retourner
          foreach($a_where as $cle2 => $valeur2) { // On parcourt le
          //tableau where à chaque ligne du fichier pour voir si
          //il correspond avec where
            if(is_array($valeur2)) {
              if(in_array($valeur[$cle2],$valeur2))
                $result[$cle] = array_merge($result[$cle],$a_mod);
            }
            else {
              if($valeur[$cle2] == $valeur2)
                $result[$cle] = array_merge($result[$cle],$a_mod);
            }
          }
        }
      }
    }
    else { // on modifie toutes les lignes
      $result = $FILE;
      
      foreach($FILE as $cle => $valeur) {
        $result[$cle] = array_merge($result[$cle],$a_mod);
      }
    }
    
    
    // FLOCK ---------------------------------------------------------
    
    $pathInf = pathinfo($u_fichier);
    $flockFilename = $pathInf["dirname"]."/".$pathInf["filename"].".flock";
    
    if($this->flock_on) {
      touch($flockFilename);
      $ffo = fopen($flockFilename,"r"); // File flock open
      flock($ffo,LOCK_EX);
    }
    else
      if(file_exists($flockFilename)) // Pour éviter les fichiers inutiles
        unlink($flockFilename);
    
    // ---------------------------------------------------------------
    
    // BACKUP --------------------------------------------------------
    
    $this->backupTest($u_fichier);
    
    // ---------------------------------------------------------------
    
    $fo = fopen($u_fichier,"w");
    
    fputs($fo,"<?php\n\$FILE_LAST_ID = $FILE_LAST_ID;\n\n");
    
    $i = 0;
    foreach($result as $cle => $valeur) {
        foreach($valeur as $cle2 => $valeur2) {
          fputs($fo,"\$FILE[$i][\"".$cle2."\"] =
          stripslashes(\"".addslashes($valeur2)."\");\n");
        }
        $i++;
    }
    
    fputs($fo,"?>");
    
    fclose($fo);
    
    // FLOCK ---------------------------------------------------------
    
    if($this->flock_on) {
      flock($ffo,LOCK_UN);
      fclose($ffo);
    }
    
    // ---------------------------------------------------------------
    
    return true;
  }
  
  public function del($u_fichier,$where) {
    if(!file_exists($u_fichier))
      return false;
    if(!isset($FILE_LAST_ID))
      $FILE_LAST_ID = 0;
    
    require($u_fichier);
    
    if(!isset($FILE))
      return false; // Il n'y a rien à retourner
    elseif(!$this->is_assoc_multi_array($FILE))
      return false;
    elseif($this->crypt_on)
      $FILE = $this->decryptTest($FILE);
    
    if($where) {
      if(!is_array($where)) {
        
        $result = $FILE;
        
        foreach($FILE as $k => $valeur) {
        // On parcourt le fichier pour trouver les lignes à retourner
          $LINE = $valeur;
          $eval = "if($where) { unset(\$result[\$k]); }";
          echo $eval."<br>";
          ob_start(); // Securité pour ne rien afficher à l'écran
          eval($eval);
          ob_clean();
        }
      }
      else {
      
        $a_where = $where;
      
        $result = $FILE;
        
        foreach($FILE as $cle => $valeur) {
        // On parcourt le fichier pour trouver les lignes à retourner
          foreach($a_where as $cle2 => $valeur2) {
          // On parcourt le tableau where à chaque ligne du fichier
          //pour voir si il correspond avec where
            if(is_array($valeur2)) {
              if(in_array($valeur[$cle2],$valeur2))
                unset($result[$cle]);
            }
            else {
              if($valeur[$cle2] == $valeur2)
                unset($result[$cle]);
            }
          }
        }
      }
    }
    else
      $result = array();
    
    // ---------------------------------------------------------------
    
    $_result = array();
    
    foreach($result as $valeur) {
    // Pour que les indices se suivent (on a supprimé certains avant)
      $_result[] = $valeur;
    }
    
    $result = $_result;
    
    // FLOCK ---------------------------------------------------------
    
    $pathInf = pathinfo($u_fichier);
    $flockFilename = $pathInf["dirname"]."/".$pathInf["filename"].".flock";
    
    if($this->flock_on) {
      touch($flockFilename);
      $ffo = fopen($flockFilename,"r"); // File flock open
      flock($ffo,LOCK_EX);
    }
    else
      if(file_exists($flockFilename)) // Pour éviter les fichiers inutiles
        unlink($flockFilename);
    
    // ---------------------------------------------------------------
    
    // BACKUP --------------------------------------------------------
    
    $this->backupTest($u_fichier);
    
    // ---------------------------------------------------------------
    
    $fo = fopen($u_fichier,"w");
    
    fputs($fo,"<?php\n\$FILE_LAST_ID = $FILE_LAST_ID;\n\n");
    
    $i = 0;
    foreach($result as $cle => $valeur) {
        foreach($valeur as $cle2 => $valeur2) {
          fputs($fo,"\$FILE[$i][\"".$cle2."\"] =
          stripslashes(\"".addslashes($valeur2)."\");\n");
        }
        $i++;
    }
    
    fputs($fo,"?>");
    
    fclose($fo);
    
    // FLOCK ---------------------------------------------------------
    
    if($this->flock_on) {
      flock($ffo,LOCK_UN);
      fclose($ffo);
    }
    
    // ---------------------------------------------------------------
    
    return true;
  }
  
  public function uRead($u_fichier) {
    if(!file_exists($u_fichier))
      return false;
    
    require($u_fichier);
    
    if(!isset($FILE))
      return array(); // Il n'y a rien à retourner

return $FILE;
  }
  
  public function uMod($u_fichier,$a_mod) {
    if(file_exists($u_fichier))
      require($u_fichier);
      
    if(!isset($FILE))
      $FILE = array();
    
    $result = array_merge($FILE,$a_mod);

// FLOCK ---------------------------------------------------------
    
    $pathInf = pathinfo($u_fichier);
    $flockFilename = $pathInf["dirname"]."/".$pathInf["filename"].".flock";
    
    if($this->flock_on) {
      touch($flockFilename);
      $ffo = fopen($flockFilename,"r"); // File flock open
      flock($ffo,LOCK_EX);
    }
    else
      if(file_exists($flockFilename)) // Pour éviter les fichiers inutiles
        unlink($flockFilename);
    
    // ---------------------------------------------------------------
    
    // BACKUP --------------------------------------------------------
    
    $this->backupTest($u_fichier);
    
    // ---------------------------------------------------------------

$fo = fopen($u_fichier,"w");
    
    fputs($fo,"<?php\n");
    
    $str_put = "\$FILE = ".var_export($result,true)."\n";
    
    fputs($fo,$str_put);
    
    fputs($fo,"?>");
    
    fclose($fo);
    
    // FLOCK ---------------------------------------------------------
    
    if($this->flock_on) {
      flock($ffo,LOCK_UN);
      fclose($ffo);
    }
    
    // ---------------------------------------------------------------
    
    return true;
  }
  
  // ---------------------------------------------------------------
  
  public function select_start($u_fichier,&$var_to_affect_read = false) {
    if(file_exists($u_fichier)) {
      require($u_fichier);
      
      if(!isset($FILE))
        $FILE = array();
      elseif($this->crypt_on)
        $FILE = $this->decryptTest($FILE);
        
      $this->select_u_fichier = $u_fichier;
      $this->select_a_read = $FILE;
      $var_to_affect_read = $FILE;
      
      return true;
    }
    else
      return false;
  }
  
  public function select() {
    $i = 0;
    
    if($this->select_a_read) {
      while(!isset($this->select_a_read[$i])) {
        $i++;
      }
      
      $result = $this->select_a_read[$i];
      unset($this->select_a_read[$i]);
      
      return $result;
    }
    else
      return false;
  }
  
  public function select_close($a_to_write) {
  
    if(!$this->select_u_fichier)
      return false;
    
    // FLOCK ---------------------------------------------------------
    
    $pathInf = pathinfo($this->select_u_fichier);
    $flockFilename = $pathInf["dirname"]."/".$pathInf["filename"].".flock";
    
    if($this->flock_on) {
      touch($flockFilename);
      $ffo = fopen($flockFilename,"r"); // File flock open
      flock($ffo,LOCK_EX);
    }
    else
      if(file_exists($flockFilename)) // Pour éviter les fichiers inutiles
        unlink($flockFilename);
    
    // ---------------------------------------------------------------
    
    // BACKUP --------------------------------------------------------
    
    $this->backupTest($this->select_u_fichier);
    
    // ---------------------------------------------------------------
    
    $result = array();
    $i = 0;
    
    if($this->crypt_on or $this->hash_on) {
      foreach($a_to_write as $valeur) {
        $result[$i] = $this->cryptAndHashTest($valeur);
        $i++;
      }
    }
    else
      $result = $a_to_write;

$fo = fopen($this->select_u_fichier,"w");
    
    fputs($fo,"<?php\n");
    
    $i = 0;
    foreach($result as $cle => $valeur) {
        foreach($valeur as $cle2 => $valeur2) {
          fputs($fo,"\$FILE[$i][\"".$cle2."\"] =
          stripslashes(\"".addslashes($valeur2)."\");\n");
        }
        $i++;
    }
    
    fputs($fo,"?>");
    
    fclose($fo);
    
    // FLOCK ---------------------------------------------------------
    
    if($this->flock_on) {
      flock($ffo,LOCK_UN);
      fclose($ffo);
    }
    
    // ---------------------------------------------------------------
    
    return true;
  }
  
  // ---------------------------------------------------------------
}

Tous les codes Classes

Fonctions du code

is_array

: Détermine si une variable est un tableau - (PHP 4, PHP 5)

array

: Crée un tableau - (PHP 4, PHP 5)

asort

: Trie un tableau et conserve l'association des index - (PHP 4, PHP 5)

md5

: Calcule le md5 d'une chaîne - (PHP 4, PHP 5, PECL hash:1.1-1.3)

base64_decode

: Décode une chaîne en MIME base64 - (PHP 4, PHP 5)

strlen

: Calcule la taille d'une chaîne - (PHP 4, PHP 5)

ord

: Retourne le code ASCII d'un caractère - (PHP 4, PHP 5)

chr

: Retourne un caractère spécifique - (PHP 4, PHP 5)

base64_encode

: Encode une chaîne en MIME base64 - (PHP 4, PHP 5)

in_array

: Indique si une valeur appartient à un tableau - (PHP 4, PHP 5)

sha1

: Calcule le sha1 d'une chaîne de caractères - (PHP 4 >= 4.3.0, PHP 5, PECL...

call_user_func

: Appelle une fonction utilisateur - (PHP 4, PHP 5)

pathinfo

: Retourne des informations sur un chemin système - (PHP 4 >= 4.0.3, PHP 5)

file_exists

: Vérifie si un fichier ou un dossier existe - (PHP 4, PHP 5)

filemtime

: Lit la date de dernière modification du fichier - (PHP 4, PHP 5)

time

: Retourne le timestamp UNIX actuel - (PHP 4, PHP 5)

copy

: Copie un fichier - (PHP 4, PHP 5)

get_magic_quotes_gpc

: Retourne la configuration actuelle de l'option magic_quotes_gpc - (PHP 4, PHP 5)

stripslashes

: Supprime les antislashs d'une chaîne - (PHP 4, PHP 5)

str_replace

: Remplace toutes les occurrences dans une chaîne - (PHP 4, PHP 5)

ctype_digit

: Vérifie qu'une chaîne est un entier - (PHP 4 >= 4.0.4, PHP 5)

explode

: Coupe une chaîne en segments - (PHP 4, PHP 5)

function_exists

: Indique si une fonction est définie - (PHP 4, PHP 5)

microtime

: Retourne le timestamp UNIX actuel avec les microsecondes - (PHP 4, PHP 5)

echo

: Affiche une chaîne de caractères - (PHP 4, PHP 5)

str_split

: Convertit une chaîne de caractères en tableau - (PHP 5)

array_reverse

: Inverse l'ordre des éléments d'un tableau - (PHP 4, PHP 5)

count

: Compte le nombre d'éléments d'un tableau ou le nombre de propriétés...

mt_rand

: Génère une meilleure valeur aléatoire - (PHP 4, PHP 5)

strtolower

: Renvoie une chaîne en minuscules - (PHP 4, PHP 5)

addslashes

: Ajoute des antislashs dans une chaîne - (PHP 4, PHP 5)

fputs

: Alias de fwrite() - (PHP 4, PHP 5)

fclose

: Ferme un fichier - (PHP 4, PHP 5)

flock

: Verrouille le fichier - (PHP 4, PHP 5)

isset

: Détermine si une variable est affectée - (PHP 4, PHP 5)

ob_start

: Enclenche la tamporisation de sortie - (PHP 4, PHP 5)

eval

: Exécute une chaîne comme un script PHP - (PHP 4, PHP 5)

ob_clean

: Efface le tampon de sortie - (PHP 4 >= 4.2.0, PHP 5)

array_merge

: Fusionne un ou plusieurs tableaux - (PHP 4, PHP 5)

touch

: Modifie la date de modification et de dernier accès d'un fichier - (PHP 4, PHP...

fopen

: Ouvre un fichier ou une URL - (PHP 4, PHP 5)

unlink

: Efface un fichier - (PHP 4, PHP 5)

unset

: Détruit une variable - (PHP 4, PHP 5)

var_export

: Retourne le code PHP utilisé pour générer une variable - (PHP 4 >= 4.2.0, PHP 5)

Commentaires

Le 26 Avril 2009 à 20:18:00

Un exemple aurai été le bienvenu .....

Le 25 Aout 2009 à 12:41:00

+1 : sans exemple ce n'est pas facile à comprendre (à moins d'explorer chaque méthode...), serait-il possible d'en avoir ?

Le 22 Juil 2010 à 10:23:00

Dommage, pas d'exemple d'utilisation ...

Ajouter un commentaire

Attention: Les champs marqués d'une étoile * sont obligatoires

Librairie PHP

Connexion

Classes

Class INIT

Class Timer

Class: Attachment Mailer

Classe MySQL

Classe Collection

Classe d'abstraction PHP4 de base de données, mysql et mssql

Classe d'abstraction PHP5 de base de données, mysql et mssql

Classe DATABASE

Classe de connexion à Mysql en PHP5

Classe Générique

CLasse permettant de gérer des formulaires

Classe pour fonction de luhn

Classe string regroupant diverses fonction string PHP

Classe XML

Classes de génération de menu (sans base de données)

Cryptage et decryptage

Date Class

Envoyer un mail type MINE en HTML

Générateur de classe

Générer des flux RSS simples ou complexes

ICQ class

Lister les noms des variables d'un objet

Moteur de déplacement sur 1 map

OLDAPHP : Module LDAP PHP orienté object

Passer les informations a une variable global depuis une classe

Retrouve et affiche l'entête de la requete HTTP

Simple TPL 0.2.3

SimpleFiles

Zip de fichier en PHP (PHPMyAdmin)

PHP

Livre PHP

PHP 5

Offres d'emploi

Plus de 500 offres d'emploi PHP/MySQL

Editeur PHP

» Editeur PHP