bituniverse.com Foren-Übersicht bituniverse.com
Entwickler Forum
 
 FAQFAQ   SuchenSuchen   MitgliederlisteMitgliederliste   BenutzergruppenBenutzergruppen   RegistrierenRegistrieren 
 ProfilProfil   Einloggen, um private Nachrichten zu lesenEinloggen, um private Nachrichten zu lesen   LoginLogin 

Rekursiv Dateien / Ordner löschen

 
Neues Thema eröffnen   Neue Antwort erstellen    bituniverse.com Foren-Übersicht -> Code-Schnipsel
Vorheriges Thema anzeigen :: Nächstes Thema anzeigen  
Autor Nachricht
Beepa



Anmeldedatum: 05.11.2007
Beiträge: 53
Wohnort: Düsseldorf

BeitragVerfasst am: Do 15 Nov, 2007 00:14    Titel: Rekursiv Dateien / Ordner löschen Antworten mit Zitat

Hier mal eine etwas ältere Klasse um rekursiv Dateien / Ordner zu löschen.
Ich muss dabei sagen, dass sie in erster Linie auf Windows-Systemen
eingesetzt wurde und von daher kein großes Augenmerk auf chmod o.ä.
gelegt wurde... Smile und wie gesagt - schon etwas älter, aber hoffentlich noch
brauchbar für den einen oder anderen Very Happy

Php:
  1. <?php
  2.  
  3. class RecursiveFileDeleteClass
  4. {
  5.   /**
  6.    * Eigenschaften deklarieren
  7.    */
  8.    
  9.   // Variable um den Pfad zu speichern
  10.   var $path;
  11.  
  12.   // Parameter für den Filter - kann sowohl ein String als auch ein Array sein
  13.   var $filter;
  14.  
  15.   // Flag ob Unterverzeichnisse durchsucht werden sollen
  16.   var $search_sub_dir;
  17.  
  18.   // Flag ob auch die Verzeichnisse / Unterverzeichnisse gelöscht werden sollen
  19.   var $delete_dir;
  20.  
  21.   // Flag ob wirklich gelöscht werden soll, oder nur ein Testmode läuft
  22.   var $mode;
  23.  
  24.   // Variable für die Ausgabe, welche Dateien/Ordner gelöscht wurden
  25.   var $delete_string;
  26.  
  27.   // diverser Zähler-Variablen
  28.   var $files_counter;
  29.   var $deleted_files_counter;
  30.   var $dir_counter;
  31.   var $deleted_dir_counter;
  32.  
  33.   /**
  34.    * Konstruktor
  35.    *
  36.    * @param     string      $path: Pfad der ausgelesen werden soll
  37.    * @param     string      $filter: Optionaler Parameter der angibt,
  38.    *            alle Dateien angezeigt werden sollen, oder ob Suchpattern erfüllt sein müssen.
  39.    *            Mehrere Pattern per Semikolon trennen - Default: all - Beispiel:
  40.    *            $filter = ".html;.php" würde alle Dateien berücksichtigen,
  41.    *            die im Namen ein ".html" oder ein ".php" beeinhalten
  42.    * @param     boolean     $search_sub_dir: Optionaler Parameter der angibt,
  43.    *            ob Unterordner durchsucht werden sollen - Default: true
  44.    * @param     boolean     $delete_dir: Optionaler Parameter der angibt,
  45.    *            ob Ordner / Unterordner gelöscht werden sollen - Default: false
  46.    * @param     string      $mode: Optionaler Parameter der angibt, ob wirklich gelöscht werden soll,
  47.    *            oder ein Testmode läuft - mögliche Werte: DELETE oder TEST - Default: DELETE        
  48.    */
  49.   function RecursiveFileDeleteClass($path, $filter = "ALL_FILES",
  50.                     $search_sub_dir = true, $delete_dir = false, $mode = "DELETE")
  51.   {    
  52.     // Zähler auf null setzen
  53.     $this->files_counter = 0;
  54.     $this->deleted_files_counter = 0;
  55.     $this->dir_counter = 0;
  56.     $this->deleted_dir_counter = 0;
  57.    
  58.     // Pfad festlegen
  59.     $this->path = $path;
  60.    
  61.     // String mit den Angaben zu den gelöschten Dateien/Ordner leeren
  62.     $this->delete_string = "";
  63.    
  64.     // Filter setzen
  65.     $this->setFilter($filter);
  66.    
  67.     // Unterverzeichnisse durchsuchen?
  68.     $this->setSearchSubDir($search_sub_dir);
  69.    
  70.     // Ordner löschen?
  71.     $this->setDeleteDir($delete_dir);
  72.    
  73.     // Wirklich löschen oder Testmode?
  74.     $this->setMode($mode);
  75.    
  76.     // Ordner auslesen
  77.     $this->readDir();
  78.     $this->dir_counter++;
  79.    
  80.     // Sollen Ordner gelöscht werden?
  81.     if($this->delete_dir == true)
  82.     {
  83.       // Funktion die Ordner löscht aufrufen
  84.       $this->deleteDir($this->path);
  85.     }
  86.  
  87.   } // ENDE: function RecursiveFileDeleteClass
  88.  
  89.  
  90.  
  91.   /**
  92.    * Funktion die ein Verzeichnis ausliest
  93.    */
  94.   function readDir()
  95.   {
  96.     // Variable in der die Struktur hinterlegt wird
  97.     $destination_path = dir($this->path);
  98.    
  99.     //Alles aus dem Verzeichnis auslesen und prüfen, ob es sich um
  100.     //einen Ordner oder eine Datei handelt
  101.     while($file = $destination_path->read())
  102.     {
  103.       if($file == ".") continue;
  104.       if($file == "..") continue;
  105.      
  106.       // Handelt es sich um ein Verzeichnis?
  107.       if(is_dir($this->path . $file))
  108.       {
  109.         $this->dir_counter++;
  110.        
  111.         // Pfad für das Unterverzeichnis festlegen
  112.         $this->path .= $file . "/";
  113.        
  114.         // Sollen Unterverzeichnisse ausgelesen werden?
  115.         if($this->search_sub_dir == true)
  116.         {
  117.           // Unterordner auslesen
  118.           $this->readDir();
  119.          
  120.         }
  121.        
  122.         // Sollen Ordner gelöscht werden?
  123.         if($this->delete_dir == true)
  124.         {
  125.           // Funktion die Ordner löscht aufrufen
  126.           $this->deleteDir($this->path);
  127.         }
  128.        
  129.         // Übergeordnetes Verzeichnis herausfiltern
  130.         $this->getParentDir();
  131.        
  132.       }
  133.       else
  134.       {
  135.         $this->files_counter++;
  136.        
  137.         // Prüfen ob ein Filter gesetzt wurde
  138.         if($this->filter != "ALL_FILES")
  139.         {
  140.           // Flag das zur Prüfung benötigt wird, ob der Filter-Wert gefunden wurde
  141.           $go = false;
  142.          
  143.           foreach($this->filter as $filter_value)
  144.           {
  145.             // Filter wurde gesetzt - Prüfen ob aktuelle Datei laut Filter gültig ist
  146.             if(strstr($file, $filter_value))
  147.             {
  148.               // Gültig
  149.               $go = true;
  150.             }
  151.           }
  152.          
  153.           // Wenn kein Filter-Wert gefunden wurde, Datei nicht berücksichtigen
  154.           if($go == false)
  155.           {
  156.             continue;
  157.           }
  158.          
  159.          
  160.         } // ENDE: if($this->filter != "ALL_FILES")
  161.        
  162.         // Funktion die Dateien löscht aufrufen
  163.         $this->deleteFile($this->path . $file);
  164.        
  165.       } // ENDE: else
  166.  
  167.     } // ENDE: while($file = $destination_path->read())
  168.    
  169.     // Ordner schließen
  170.     $destination_path->close();
  171.  
  172.   } // ENDE: function readDir()
  173.  
  174.  
  175.  
  176.   /**
  177.    * (Hilfs)Funktion die den Filter festlegt
  178.    *
  179.    * @param     string      $filter: Parameter der angibt, ob alle Dateien angezeigt werden sollen,
  180.    * oder ob Suchpattern erfüllt sein müssen.
  181.    * Mehrere Pattern per Semikolon trennen - Default: all - Beispiel:
  182.    * $filter = ".html;.php" würde alle Dateien berücksichtigen,
  183.    * die im Namen ein ".html" oder ein ".php" beeinhalten
  184.    */
  185.   function setFilter($filter)
  186.   {
  187.     // Filter festlegen
  188.     switch($filter)
  189.     {
  190.       case "ALL_FILES":
  191.         $this->filter = "ALL_FILES";
  192.         break;
  193.      
  194.       default:
  195.         $this->filter = explode(";", $filter);
  196.         break;
  197.     } // ENDE: switch($filter)
  198.    
  199.   } // ENDE: function setFilter($filter)
  200.  
  201.  
  202.  
  203.  
  204.   /**
  205.    * (Hilfs)Funktion die festlegt, ob Unterverzeichnisse auch durchsucht werden sollen
  206.    *
  207.    * @param     boolean     $search_sub_dir: Parameter der angibt,
  208.    * ob Unterverzeichnisse auch durchsucht werden sollen
  209.    */
  210.   function setSearchSubDir($search_sub_dir)
  211.   {
  212.     // Festlegen, ob Unterverzeichnisse auch durchsucht werden sollen
  213.     switch($search_sub_dir)
  214.     {
  215.       case true:
  216.         $this->search_sub_dir = true;
  217.         break;
  218.      
  219.       case false:
  220.         $this->search_sub_dir = false;
  221.         break;
  222.      
  223.       default:
  224.         $this->search_sub_dir = true;
  225.         break;
  226.     } // ENDE: switch($search_sub_dir)
  227.    
  228.   } // ENDE: function setSearchSubDir($search_sub_dir)
  229.  
  230.  
  231.  
  232.   /**
  233.    * (Hilfs)Funktion die festlegt, ob wirklich gelöscht werden soll, oder ein Testmode läuft
  234.    *
  235.    * @param     string      $mode: Parameter der angibt, ob wirklich gelöscht werden soll,
  236.    * oder ein Testmode läuft
  237.    */
  238.   function setMode($mode)
  239.   {
  240.     // Festlegen, ob gelöscht werden soll
  241.     switch($mode)
  242.     {
  243.       case "DELETE":
  244.         $this->mode = "DELETE";
  245.         break;
  246.      
  247.       case "TEST":
  248.         $this->mode = "TEST";
  249.         break;
  250.      
  251.       default:
  252.         $this->mode = "DELETE";
  253.         break;
  254.     } // ENDE: switch($mode)
  255.    
  256.   } // ENDE: function setMode($mode)
  257.  
  258.  
  259.  
  260.   /**
  261.    * (Hilfs)Funktion die festlegt, ob auch Ordner gelöscht werden sollen
  262.    *
  263.    * @param     boolean     $delete_dir: Parameter der angibt, ob auch Ordner gelöscht werden soll
  264.    */
  265.   function setDeleteDir($delete_dir)
  266.   {
  267.     // Festlegen, ob auch Ordner gelöscht werden sollen
  268.     switch($delete_dir)
  269.     {
  270.       case true:
  271.         $this->delete_dir = true;
  272.         break;
  273.      
  274.       case false:
  275.         $this->delete_dir = false;
  276.         break;
  277.      
  278.       default:
  279.         $this->delete_dir = false;
  280.         break;
  281.     } // ENDE: switch($delete_dir)
  282.    
  283.   } // ENDE: function setDeleteDir($delete_dir)
  284.  
  285.  
  286.  
  287.   /**
  288.    * Funktion die den Pfad des übergeordneten Verzeichnisses ermittelt
  289.    */
  290.   function getParentDir()
  291.   {
  292.     // Aktuellen Pfad in ein Array aufsplitten
  293.     $tmp = explode("/", $this->path);
  294.    
  295.     // Aktuellen Pfad löschen
  296.     $this->path = "";
  297.    
  298.     // Übergeordneten Pfad zusammensetzen
  299.     for($i = 0; $i < count($tmp) - 2; $i++)
  300.     {
  301.       $this->path .= $tmp[$i] . "/";
  302.     }
  303.   } // ENDE: function getParentDir()
  304.  
  305.  
  306.  
  307.   /**
  308.    * Funktion die Datein löscht
  309.    *
  310.    * @param     string      $file: Angabe des Dateipfades einschl. dem Dateinamen
  311.    */
  312.   function deleteFile($file)
  313.   {
  314.     // Icon dem Ausgabestring hinzufügen
  315.     $this->delete_string .= '<img src="text.gif" border="0">&nbsp;<a style="font-family: Arial; font-size: 10pt;">';
  316.    
  317.     // Mode überprüfen
  318.     if($this->mode == "DELETE")
  319.     {
  320.       // Versuchen die Datei zu löschen
  321.       if(@unlink($file))
  322.       {
  323.         $this->deleted_files_counter++;
  324.         $this->delete_string .= 'Datei: ' . $file . ' wurde gelöscht';
  325.       }
  326.       else
  327.       {
  328.         $this->delete_string .= '<b style="color: #FF0000;">konnte Datei: ' . $file . ' nicht löschen!</b>';
  329.       }
  330.     }
  331.     else
  332.     {
  333.       // Testmode läuft
  334.       $this->delete_string .= 'jetzt würde die Datei: <b>' . $file . '</b> gelöscht werden...';
  335.     }
  336.    
  337.     // a-Tag wieder schließen
  338.     $this->delete_string .= '</a><br />' . "\n";
  339.    
  340.   } // ENDE: function deleteFile($file)
  341.  
  342.  
  343.  
  344.   /**
  345.    * Funktion die Ordner löscht
  346.    *
  347.    * @param     string      $dir: Pfad des zu löschenden Ordners
  348.    */
  349.   function deleteDir($dir)
  350.   {
  351.     // Icon dem Ausgabestring hinzufügen und a-Tag öffnen
  352.     $this->delete_string .= '<img src="dir.gif" border="0">&nbsp;<a style="font-family: Arial; font-size: 10pt;">';
  353.    
  354.     // Mode überprüfen
  355.     if($this->mode == "DELETE")
  356.     {
  357.       // Versuchen Ordner zu löschen
  358.       if(@rmdir($dir))
  359.       {
  360.         $this->deleted_dir_counter++;
  361.         $this->delete_string .= 'Ordner: ' . $dir . ' wurde gelöscht';
  362.       }
  363.       else
  364.       {
  365.         $this->delete_string .= '<b style="color: #FF0000;">konnte Ordner: <u>' . $dir . '</u> nicht löschen!</b>';
  366.       }
  367.     }
  368.     else
  369.     {
  370.       // Testmode läuft
  371.       $this->delete_string .= 'jetzt würde der Ordner: <b>' . $dir . '</b> gelöscht werden...';
  372.     }
  373.    
  374.     // a-Tag wieder schließen
  375.     $this->delete_string .= '</a><br />' . "\n";
  376.    
  377.   } // ENDE: function deleteDir($dir)
  378.  
  379.  
  380.  
  381. } // ENDE: class RecursiveFileDeleteClass
  382.  
  383. ?>

Beispiel-Aufruf der Klasse:

Php:
  1. <?php
  2.  
  3.   /**
  4.    * Beispiel-Aufrufe:
  5.    */
  6.    
  7.   // Scriptlaufzeit auf unbegrenzt setzen
  8.  
  9.   // Klasse einbinden
  10.   include("RecursiveFileDeleteClass.class.php");
  11.    
  12.   // Parameter festlegen
  13.   $path = "./Testordner/";
  14.  
  15.   $filter = "ALL_FILES";
  16.   //$filter = ".txt;.xls";
  17.  
  18.   //$search_sub_dir = false;
  19.   $search_sub_dir = true;
  20.  
  21.   //$delete_dir = false;
  22.   $delete_dir = true;
  23.  
  24.   $mode = "TEST";
  25.   //$mode = "DELETE";
  26.  
  27.   // Neue Instanz der Klasse aufrufen
  28.   $test = new RecursiveFileDeleteClass($path, $filter, $search_sub_dir, $delete_dir, $mode);
  29.  
  30.   echo $test->delete_string . "<hr>";
  31.   echo "Von " . $test->dir_counter . " Ordnern wurden " . $test->deleted_dir_counter . " Ordner gelöscht...<br />";
  32.   echo "Von " . $test->files_counter . " Dateien wurden " . $test->deleted_files_counter . " Dateien gelöscht...<br />";
  33.  
  34. ?>

Edit von Slava: Zeilenlänge angepasst

Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Beiträge der letzten Zeit anzeigen:   
Neues Thema eröffnen   Neue Antwort erstellen    bituniverse.com Foren-Übersicht -> Code-Schnipsel Alle Zeiten sind GMT + 1 Stunde
Seite 1 von 1

 
Gehe zu:  
Du kannst Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.


Powered by phpBB © 2001, 2005 phpBB Group
Deutsche Übersetzung von phpBB2.de
Powered by WebRing.