Usunąć katalog z plikami?

Zastanawiam się, jaki jest najłatwiejszy sposób na usunięcie katalogu ze wszystkimi jego plikami?

Używam rmdir(PATH . '/' . $value);do usuwania folderu, jednak jeśli są w nim pliki, po prostu nie mogę go usunąć.

Obecnie dostępne są co najmniej dwie opcje.

1. Przed usunięciem folderu usuń wszystkie jego pliki i foldery (a to oznacza rekurencję!). Oto przykład:

   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. A jeśli używasz wersji 5.2+, możesz użyć RecursiveIterator, aby to zrobić bez samodzielnego wdrażania rekursji:

   $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);

Zwykle używam tego do usuwania wszystkich plików w folderze:

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

I wtedy możesz zrobić

rmdir($dirname);

jaki jest najprostszy sposób na usunięcie katalogu zawierającego wszystkie pliki?

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

Krótka funkcja, która wykonuje zadanie:

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

Używam go w klasie Utils, takiej jak ta:

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);
    }
}

Z wielką mocą wiąże się wielka odpowiedzialność : wywołanie tej funkcji pustą wartością spowoduje usunięcie plików zaczynających się w root ( /). Jako zabezpieczenie możesz sprawdzić, czy ścieżka jest pusta:

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

Jak widać w najczęściej głosowanych komentarzach na stronie podręcznika PHP o rmdir()(patrz http://php.net/manual/es/function.rmdir.php ), glob()funkcja nie zwraca ukrytych plików. scandir()stanowi alternatywę, która rozwiązuje ten problem.

Opisany tam algorytm (który w moim przypadku działał jak urok) to:

<?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); 
    } 
?>

To krótsza wersja działa dla mnie świetnie

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);
    }
}

Możesz użyć systemu plików Symfony ( kod ):

// composer require symfony/filesystem

use Symfony\Component\Filesystem\Filesystem;

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

Jednak nie mogłem usunąć niektórych złożonych struktur katalogów za pomocą tej metody, więc najpierw powinieneś spróbować, aby upewnić się, że działa poprawnie.

Mógłbym usunąć wspomnianą strukturę katalogów za pomocą implementacji specyficznej dla systemu Windows:

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

I tylko dla kompletności, oto mój stary kod:

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);
}

Oto jedna przyjemna i prosta rekursja do usunięcia wszystkich plików w katalogu źródłowym, w tym katalogu:

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);

}

Funkcja opiera się na rekursji wykonanej dla kopiowania katalogu. Możesz znaleźć tę funkcję tutaj: Skopiuj całą zawartość katalogu do innego za pomocą php

Najlepsze rozwiązanie dla mnie

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

kod:

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 PAMIĘTAJ!
nie przekazuj PUSTEJ WARTOŚCI do żadnych funkcji usuwania katalogu !!! (zawsze wykonuj kopie zapasowe, w przeciwnym razie pewnego dnia możesz dostać katastrofę !!)

A co z tym:

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);
}

Funkcja Glob nie zwraca ukrytych plików, dlatego scandir może być bardziej przydatny podczas próby rekurencyjnego usunięcia drzewa.

<?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);
  }
?>

Możesz spróbować wykonać następujące czynności:

/*
 * 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);
        }
    }
}

Wolę to, ponieważ nadal zwraca PRAWDA, gdy się powiedzie, i FAŁSZ, gdy się nie powiedzie, a także zapobiega błędowi, w którym pusta ścieżka może próbować usunąć wszystko z „/ *” !!:

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);
}

Chcę rozwinąć odpowiedź autorstwa @alcuadrado z komentarzem @Vijit dotyczącym obsługi dowiązań symbolicznych. Po pierwsze, użyj getRealPath (). Ale jeśli masz jakieś dowiązania symboliczne, które są folderami, to się nie powiedzie, ponieważ spróbuje wywołać rmdir na link - więc potrzebujesz dodatkowej kontroli.

$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);

Korzystanie z DirectoryIterator odpowiada poprzedniej odpowiedzi…

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);
}

Ten działa dla mnie:

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

Coś takiego?

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

Mała modyfikacja kodu alcuadrado - globnie widzę plików o nazwach z punktów takich jak, .htaccesswięc używam skandiru, a skrypt usuwa się sam - sprawdź __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);
}

Przykład dla serwera Linux: exec('rm -f -r ' . $cache_folder . '/*');

Usuń wszystkie pliki w folderze
array_map('unlink', glob("$directory/*.*"));
Usuń wszystko. * - Pliki w folderze (bez: „.” I „..”)
array_map('unlink', array_diff(glob("$directory/.*),array("$directory/.","$directory/..")))
Teraz usuń sam folder
rmdir($directory)

2 centy, aby dodać do tej odpowiedzi powyższej , co jest świetne BTW

Po zeskanowaniu / przeczytaniu katalogu przez funkcję glob (lub podobną) dodaj warunek, aby sprawdzić, czy odpowiedź nie jest pusta lub zostanie invalid argument supplied for foreach()wyświetlone ostrzeżenie. Więc...

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

Moja pełna funkcja (jako metoda obiektowa):

    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()

Oto rozwiązanie, które działa idealnie:

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;
}

Możesz skopiować pomocników YII

$ katalog (ciąg) - do rekurencyjnego usunięcia.

$ options (array) - do usunięcia katalogu. Prawidłowe opcje to: traverseSymlinks: boolean, czy dowiązania symboliczne do katalogów również powinny być przechodzące. Domyślnie falseoznacza to, że zawartość dowiązania symbolicznego nie zostanie usunięta. W takim przypadku domyślnym zostanie usunięte tylko dowiązanie symboliczne.

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);
  }
 }
?>

Spróbuj wypróbować poniższy kod z php.net

Pracuj dla mnie dobrze

Dla Windowsa:

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

Podobnie jak rozwiązanie Playnox, ale z eleganckim wbudowanym 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!');
  }
 }

Nie pamiętam, skąd skopiowałem tę funkcję, ale wygląda na to, że nie ma jej na liście i działa dla mnie

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);
    }
}

Proste i łatwe...

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

A co z tym?

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 );  
  }
}

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

Jeśli nie masz pewności, podana ścieżka to katalog lub plik, możesz użyć tej funkcji do usunięcia ścieżki

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;
        }
}