Verzeichnis mit darin enthaltenen Dateien löschen?

Ich frage mich, wie man ein Verzeichnis mit all seinen Dateien am einfachsten löscht.

Ich verwende rmdir(PATH . '/' . $value);, um einen Ordner zu löschen. Wenn sich jedoch Dateien darin befinden, kann ich ihn einfach nicht löschen.

Heutzutage stehen mindestens zwei Optionen zur Verfügung.

1. Löschen Sie vor dem Löschen des Ordners alle Dateien und Ordner (und dies bedeutet Rekursion!). Hier ist ein Beispiel:

   public static function deleteDir($dirPath) {
       if (! is_dir($dirPath)) {
           throw new InvalidArgumentException("$dirPath must be a directory");
       }
       if (substr($dirPath, strlen($dirPath) - 1, 1) != '/') {
           $dirPath .= '/';
       }
       $files = glob($dirPath . '*', GLOB_MARK);
       foreach ($files as $file) {
           if (is_dir($file)) {
               self::deleteDir($file);
           } else {
               unlink($file);
           }
       }
       rmdir($dirPath);
   }

2. Und wenn Sie 5.2+ verwenden, können Sie einen RecursiveIterator verwenden, ohne die Rekursion selbst zu implementieren:

   $dir = 'samples' . DIRECTORY_SEPARATOR . 'sampledirtree';
   $it = new RecursiveDirectoryIterator($dir, RecursiveDirectoryIterator::SKIP_DOTS);
   $files = new RecursiveIteratorIterator($it,
                RecursiveIteratorIterator::CHILD_FIRST);
   foreach($files as $file) {
       if ($file->isDir()){
           rmdir($file->getRealPath());
       } else {
           unlink($file->getRealPath());
       }
   }
   rmdir($dir);

Ich benutze dies im Allgemeinen, um alle Dateien in einem Ordner zu löschen:

array_map('unlink', glob("$dirname/*.*"));

Und dann kannst du es tun

rmdir($dirname);

Was ist der einfachste Weg, ein Verzeichnis mit all seinen Dateien zu löschen?

system("rm -rf ".escapeshellarg($dir));

Kurze Funktion, die den Job macht:

function deleteDir($path) {
    return is_file($path) ?
            @unlink($path) :
            array_map(__FUNCTION__, glob($path.'/*')) == @rmdir($path);
}

Ich benutze es in einer Utils-Klasse wie dieser:

class Utils {
    public static function deleteDir($path) {
        $class_func = array(__CLASS__, __FUNCTION__);
        return is_file($path) ?
                @unlink($path) :
                array_map($class_func, glob($path.'/*')) == @rmdir($path);
    }
}

Mit großer Kraft geht eine große Verantwortung einher : Wenn Sie diese Funktion mit einem leeren Wert aufrufen, werden Dateien gelöscht, die mit root ( /) beginnen. Als Schutz können Sie überprüfen, ob der Pfad leer ist:

function deleteDir($path) {
    if (empty($path)) { 
        return false;
    }
    return is_file($path) ?
            @unlink($path) :
            array_map(__FUNCTION__, glob($path.'/*')) == @rmdir($path);
}

Wie in den meisten Stimmen auf der PHP-Handbuchseite zu rmdir()(siehe http://php.net/manual/es/function.rmdir.php ) zu sehen ist, gibt die glob()Funktion keine versteckten Dateien zurück. scandir()wird als Alternative bereitgestellt, um dieses Problem zu lösen.

Der dort beschriebene Algorithmus (der in meinem Fall wie ein Zauber wirkte) ist:

<?php 
    function delTree($dir)
    { 
        $files = array_diff(scandir($dir), array('.', '..')); 

        foreach ($files as $file) { 
            (is_dir("$dir/$file")) ? delTree("$dir/$file") : unlink("$dir/$file"); 
        }

        return rmdir($dir); 
    } 
?>

Dies ist eine kürzere Version, die für mich großartig funktioniert

function deleteDirectory($dirPath) {
    if (is_dir($dirPath)) {
        $objects = scandir($dirPath);
        foreach ($objects as $object) {
            if ($object != "." && $object !="..") {
                if (filetype($dirPath . DIRECTORY_SEPARATOR . $object) == "dir") {
                    deleteDirectory($dirPath . DIRECTORY_SEPARATOR . $object);
                } else {
                    unlink($dirPath . DIRECTORY_SEPARATOR . $object);
                }
            }
        }
    reset($objects);
    rmdir($dirPath);
    }
}

Sie können das Dateisystem ( Code ) von Symfony verwenden :

// composer require symfony/filesystem

use Symfony\Component\Filesystem\Filesystem;

(new Filesystem)->remove($dir);

Ich konnte jedoch einige komplexe Verzeichnisstrukturen mit dieser Methode nicht löschen. Versuchen Sie es daher zunächst, um sicherzustellen, dass sie ordnungsgemäß funktioniert.

Ich könnte diese Verzeichnisstruktur mit einer Windows-spezifischen Implementierung löschen:

$dir = strtr($dir, '/', '\\');
// quotes are important, otherwise one could
// delete "foo" instead of "foo bar"
system('RMDIR /S /Q "'.$dir.'"');

Und der Vollständigkeit halber hier ein alter Code von mir:

function xrmdir($dir) {
    $items = scandir($dir);
    foreach ($items as $item) {
        if ($item === '.' || $item === '..') {
            continue;
        }
        $path = $dir.'/'.$item;
        if (is_dir($path)) {
            xrmdir($path);
        } else {
            unlink($path);
        }
    }
    rmdir($dir);
}

Hier haben Sie eine schöne und einfache Rekursion zum Löschen aller Dateien im Quellverzeichnis einschließlich dieses Verzeichnisses:

function delete_dir($src) { 
    $dir = opendir($src);
    while(false !== ( $file = readdir($dir)) ) { 
        if (( $file != '.' ) && ( $file != '..' )) { 
            if ( is_dir($src . '/' . $file) ) { 
                delete_dir($src . '/' . $file); 
            } 
            else { 
                unlink($src . '/' . $file); 
            } 
        } 
    } 
    closedir($dir); 
    rmdir($src);

}

Die Funktion basiert auf einer Rekursion zum Kopieren des Verzeichnisses. Diese Funktion finden Sie hier: Kopieren Sie den gesamten Inhalt eines Verzeichnisses mit PHP in ein anderes

Die beste Lösung für mich

my_folder_delete("../path/folder");

Code:

function my_folder_delete($path) {
    if(!empty($path) && is_dir($path) ){
        $dir  = new RecursiveDirectoryIterator($path, RecursiveDirectoryIterator::SKIP_DOTS); //upper dirs are not included,otherwise DISASTER HAPPENS :)
        $files = new RecursiveIteratorIterator($dir, RecursiveIteratorIterator::CHILD_FIRST);
        foreach ($files as $f) {if (is_file($f)) {unlink($f);} else {$empty_dirs[] = $f;} } if (!empty($empty_dirs)) {foreach ($empty_dirs as $eachDir) {rmdir($eachDir);}} rmdir($path);
    }
}

ps ERINNERN SIE SICH!
Übergeben Sie keine leeren Werte an Funktionen zum Löschen von Verzeichnissen !!! (Sichern Sie sie immer, sonst könnten Sie eines Tages DISASTER bekommen !!)

Was ist damit:

function recursiveDelete($dirPath, $deleteParent = true){
    foreach(new RecursiveIteratorIterator(new RecursiveDirectoryIterator($dirPath, FilesystemIterator::SKIP_DOTS), RecursiveIteratorIterator::CHILD_FIRST) as $path) {
        $path->isFile() ? unlink($path->getPathname()) : rmdir($path->getPathname());
    }
    if($deleteParent) rmdir($dirPath);
}

Die Glob-Funktion gibt die versteckten Dateien nicht zurück, daher kann scandir nützlicher sein, wenn Sie versuchen, einen Baum rekursiv zu löschen.

<?php
public static function delTree($dir) {
   $files = array_diff(scandir($dir), array('.','..'));
    foreach ($files as $file) {
      (is_dir("$dir/$file")) ? delTree("$dir/$file") : unlink("$dir/$file");
    }
    return rmdir($dir);
  }
?>

Sie können Folgendes versuchen:

/*
 * Remove the directory and its content (all files and subdirectories).
 * @param string $dir the directory name
 */
function rmrf($dir) {
    foreach (glob($dir) as $file) {
        if (is_dir($file)) { 
            rmrf("$file/*");
            rmdir($file);
        } else {
            unlink($file);
        }
    }
}

Ich bevorzuge dies, weil es immer noch TRUE zurückgibt, wenn es erfolgreich ist, und FALSE, wenn es fehlschlägt, und es verhindert auch einen Fehler, bei dem ein leerer Pfad versuchen könnte, alles aus '/ *' zu löschen !!:

function deleteDir($path)
{
    return !empty($path) && is_file($path) ?
        @unlink($path) :
        (array_reduce(glob($path.'/*'), function ($r, $i) { return $r && deleteDir($i); }, TRUE)) && @rmdir($path);
}

Ich möchte die Antwort von @alcuadrado mit dem Kommentar von @Vijit zum Umgang mit Symlinks erweitern. Verwenden Sie zunächst getRealPath (). Wenn Sie jedoch Symlinks haben, bei denen es sich um Ordner handelt, schlägt dies fehl, da versucht wird, rmdir für einen Link aufzurufen. Sie benötigen daher eine zusätzliche Überprüfung.

$it = new RecursiveDirectoryIterator($dir, RecursiveDirectoryIterator::SKIP_DOTS);
$files = new RecursiveIteratorIterator($it, RecursiveIteratorIterator::CHILD_FIRST);
foreach($files as $file) {
    if ($file->isLink()) {
        unlink($file->getPathname());
    } else if ($file->isDir()){
        rmdir($file->getPathname());
    } else {
        unlink($file->getPathname());
    }
}
rmdir($dir);

Verwenden von DirectoryIterator entspricht einer vorherigen Antwort…

function deleteFolder($rootPath)
{   
    foreach(new DirectoryIterator($rootPath) as $fileToDelete)
    {
        if($fileToDelete->isDot()) continue;
        if ($fileToDelete->isFile())
            unlink($fileToDelete->getPathName());
        if ($fileToDelete->isDir())
            deleteFolder($fileToDelete->getPathName());
    }

    rmdir($rootPath);
}

Dieser funktioniert für mich:

function removeDirectory($path) {
    $files = glob($path . '/*');
    foreach ($files as $file) {
        is_dir($file) ? removeDirectory($file) : unlink($file);
    }
    rmdir($path);
    return;
}

Etwas wie das?

function delete_folder($folder) {
    $glob = glob($folder);
    foreach ($glob as $g) {
        if (!is_dir($g)) {
            unlink($g);
        } else {
            delete_folder("$g/*");
            rmdir($g);
        }
    }
}

Kleine Änderung des Codes von Alcuadrado - globkeine Dateien mit Namen von Punkten wie z. .htaccessB. Scandir verwenden und Skript löscht sich selbst - überprüfen __FILE__.

function deleteDir($dirPath) {
    if (!is_dir($dirPath)) {
        throw new InvalidArgumentException("$dirPath must be a directory");
    }
    if (substr($dirPath, strlen($dirPath) - 1, 1) != '/') {
        $dirPath .= '/';
    }
    $files = scandir($dirPath); 
    foreach ($files as $file) {
        if ($file === '.' || $file === '..') continue;
        if (is_dir($dirPath.$file)) {
            deleteDir($dirPath.$file);
        } else {
            if ($dirPath.$file !== __FILE__) {
                unlink($dirPath.$file);
            }
        }
    }
    rmdir($dirPath);
}

Beispiel für den Linux-Server: exec('rm -f -r ' . $cache_folder . '/*');

Alle Dateien im Ordner
array_map('unlink', glob("$directory/*.*"));
löschen Alle
array_map('unlink', array_diff(glob("$directory/.*),array("$directory/.","$directory/..")))
löschen . * - Dateien im Ordner (ohne: "." Und "..") Löschen Sie nun den Ordner selbst
rmdir($directory)

2 Cent zu dieser Antwort oben hinzufügen , was übrigens großartig ist

Nachdem Ihre Glob-Funktion (oder eine ähnliche Funktion) das Verzeichnis gescannt / gelesen hat, fügen Sie eine Bedingung hinzu, um zu überprüfen, ob die Antwort nicht leer ist. invalid argument supplied for foreach()Andernfalls wird eine Warnung ausgegeben. So...

if( ! empty( $files ) )
{
    foreach( $files as $file )
    {
        // do your stuff here...
    }
}

Meine volle Funktion (als Objektmethode):

    private function recursiveRemoveDirectory( $directory )
    {
        if( ! is_dir( $directory ) )
        {
            throw new InvalidArgumentException( "$directory must be a directory" );
        }

        if( substr( $directory, strlen( $directory ) - 1, 1 ) != '/' )
        {
            $directory .= '/';
        }

        $files = glob( $directory . "*" );

        if( ! empty( $files ) )
        {
            foreach( $files as $file )
            {
                if( is_dir( $file ) )
                {
                    $this->recursiveRemoveDirectory( $file );
                }
                else
                {
                    unlink( $file );
                }
            }               
        }
        rmdir( $directory );

    } // END recursiveRemoveDirectory()

Hier ist die Lösung, die perfekt funktioniert:

function unlink_r($from) {
    if (!file_exists($from)) {return false;}
    $dir = opendir($from);
    while (false !== ($file = readdir($dir))) {
        if ($file == '.' OR $file == '..') {continue;}

        if (is_dir($from . DIRECTORY_SEPARATOR . $file)) {
            unlink_r($from . DIRECTORY_SEPARATOR . $file);
        }
        else {
            unlink($from . DIRECTORY_SEPARATOR . $file);
        }
    }
    rmdir($from);
    closedir($dir);
    return true;
}

Sie könnten die YII-Helfer kopieren

$ directory (string) - wird rekursiv gelöscht.

$ options (Array) - zum Entfernen des Verzeichnisses. Gültige Optionen sind: traverseSymlinks: boolean, ob auch Symlinks zu den Verzeichnissen durchlaufen werden sollen. Der Standardwert ist false, dass der Inhalt des verknüpften Verzeichnisses nicht gelöscht wird. In diesem Standardfall wird nur der Symlink entfernt.

public static function removeDirectory($directory,$options=array())
{
    if(!isset($options['traverseSymlinks']))
        $options['traverseSymlinks']=false;
    $items=glob($directory.DIRECTORY_SEPARATOR.'{,.}*',GLOB_MARK | GLOB_BRACE);
    foreach($items as $item)
    {
        if(basename($item)=='.' || basename($item)=='..')
            continue;
        if(substr($item,-1)==DIRECTORY_SEPARATOR)
        {
            if(!$options['traverseSymlinks'] && is_link(rtrim($item,DIRECTORY_SEPARATOR)))
                unlink(rtrim($item,DIRECTORY_SEPARATOR));
            else
                self::removeDirectory($item,$options);
        }
        else
            unlink($item);
    }
    if(is_dir($directory=rtrim($directory,'\\/')))
    {
        if(is_link($directory))
            unlink($directory);
        else
            rmdir($directory);
    }
}

<?php
  function rrmdir($dir) {
  if (is_dir($dir)) {
    $objects = scandir($dir);
    foreach ($objects as $object) {
      if ($object != "." && $object != "..") {
        if (filetype($dir."/".$object) == "dir") 
           rrmdir($dir."/".$object); 
        else unlink   ($dir."/".$object);
      }
    }
    reset($objects);
    rmdir($dir);
  }
 }
?>

Lassen Sie den obigen Code von php.net ausprobieren

Arbeite gut für mich

Für Windows:

system("rmdir ".escapeshellarg($path) . " /s /q");

Wie die Lösung von Playnox, jedoch mit dem eleganten integrierten DirectoryIterator:

function delete_directory($dirPath){
 if(is_dir($dirPath)){
  $objects=new DirectoryIterator($dirPath);
   foreach ($objects as $object){
    if(!$object->isDot()){
     if($object->isDir()){
      delete_directory($object->getPathname());
     }else{
      unlink($object->getPathname());
     }
    }
   }
   rmdir($dirPath);
  }else{
   throw new Exception(__FUNCTION__.'(dirPath): dirPath is not a directory!');
  }
 }

Ich erinnere mich nicht, woher ich diese Funktion kopiert habe, aber es sieht so aus, als ob sie nicht aufgeführt ist und für mich funktioniert

function rm_rf($path) {
    if (@is_dir($path) && is_writable($path)) {
        $dp = opendir($path);
        while ($ent = readdir($dp)) {
            if ($ent == '.' || $ent == '..') {
                continue;
            }
            $file = $path . DIRECTORY_SEPARATOR . $ent;
            if (@is_dir($file)) {
                rm_rf($file);
            } elseif (is_writable($file)) {
                unlink($file);
            } else {
                echo $file . "is not writable and cannot be removed. Please fix the permission or select a new path.\n";
            }
        }
        closedir($dp);
        return rmdir($path);
    } else {
        return @unlink($path);
    }
}

Simpel und einfach...

$dir ='pathtodir';
if (is_dir($dir)) {
  foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path)) as $filename) {
    if ($filename->isDir()) continue;
    unlink($filename);
  }
  rmdir($dir);
}

Was ist damit?

function Delete_Directory($Dir) 
{
  if(is_dir($Dir))
  {
      $files = glob( $Dir . '*', GLOB_MARK ); //GLOB_MARK adds a slash to directories returned

      foreach( $files as $file )
      {
          Delete_Directory( $file );      
      }
      if(file_exists($Dir))
      {
          rmdir($Dir);
      }
  } 
  elseif(is_file($Dir)) 
  {
     unlink( $Dir );  
  }
}

Aktualisierung: https://paulund.co.uk/php-delete-directory-and-files-in-directory

Wenn Sie sich nicht sicher sind, ob der angegebene Pfad ein Verzeichnis oder eine Datei ist, können Sie mit dieser Funktion den Pfad löschen

function deletePath($path) {
        if(is_file($path)){
            unlink($path);
        } elseif(is_dir($path)){
            $path = (substr($path, -1) !== DIRECTORY_SEPARATOR) ? $path . DIRECTORY_SEPARATOR : $path;
            $files = glob($path . '*');
            foreach ($files as $file) {
                deleteDirPath($file);
            }
            rmdir($path);
        } else {
            return false;
        }
}