Come posso eliminare ricorsivamente una directory e il suo intero contenuto (file + directory secondarie) in PHP?

Risposte:

207

La sezione rmdirfornita dall'utente nella pagina del manuale contiene un'implementazione decente:

 function rrmdir($dir) { 
   if (is_dir($dir)) { 
     $objects = scandir($dir);
     foreach ($objects as $object) { 
       if ($object != "." && $object != "..") { 
         if (is_dir($dir. DIRECTORY_SEPARATOR .$object) && !is_link($dir."/".$object))
           rrmdir($dir. DIRECTORY_SEPARATOR .$object);
         else
           unlink($dir. DIRECTORY_SEPARATOR .$object); 
       } 
     }
     rmdir($dir); 
   } 
 }
— artefacto
fonte
1
@ The Pixel Developer - Ho aggiunto una risposta che lo dimostra.
— salathe il
2
estrarre la soluzione qualcuno mi ha dato per la stessa domanda: glob sembra funzionare più bello: stackoverflow.com/questions/11267086/...
— NoodleOfDeath
Ciò chiama is_dirdue volte per ogni directory ricorsiva. Se l'argomento è un collegamento simbolico, lo segue anche invece di eliminare il collegamento simbolico, che potrebbe essere o meno quello che desideri. In ogni caso, non è ciò che rm -rffa.
— Vladimir Panteleev,
116

Basandosi sul commento di The Pixel Developer , uno snippet che utilizza SPL potrebbe apparire come:

$files = new RecursiveIteratorIterator(
    new RecursiveDirectoryIterator($dir, RecursiveDirectoryIterator::SKIP_DOTS),
    RecursiveIteratorIterator::CHILD_FIRST
);

foreach ($files as $fileinfo) {
    $todo = ($fileinfo->isDir() ? 'rmdir' : 'unlink');
    $todo($fileinfo->getRealPath());
}

rmdir($dir);

Nota: non esegue alcun controllo di integrità e utilizza il flag SKIP_DOTS introdotto con FilesystemIterator in PHP 5.3.0. Certo, $todopotrebbe essere un if/ else. Il punto importante è che CHILD_FIRSTviene utilizzato per scorrere i file secondari (file) prima dei loro genitori (cartelle).

— Salathe
fonte
SKIP_DOTSè stato introdotto solo in PHP 5.3? Dove l'hai visto?
— Alix Axel,
Grazie. Inoltre: non dovresti usare il getPathname()metodo invece di getRealPath()?
— Alix Axel,
3
Questa soluzione funziona bene, tuttavia elimina tutto ... tranne la directory (vuota o no). Ci dovrebbe essere un rmdir($dir)alla fine della sceneggiatura.
— Laurent,
3
Ecco la stessa funzione non imballata, bloccata da documenti e resa coerente con rmdir()e unlink(), ad esempio, interrompe E_WARNINGe restituisce trueo falseindica il successo.
— mindplay.dk,
2
@dbf no non lo farà, FilesystemIteratornon è un iteratore ricorsivo.
— salathe
17

Elimina tutti i file e le cartelle nel percorso.

function recurseRmdir($dir) {
  $files = array_diff(scandir($dir), array('.','..'));
  foreach ($files as $file) {
    (is_dir("$dir/$file")) ? recurseRmdir("$dir/$file") : unlink("$dir/$file");
  }
  return rmdir($dir);
}
— Liko
fonte
1
rm -rf /== recurseRmdir('/'):)
— Aaron Esau
5
Si prega di notare che questo non è symlink sicuro! È necessario un controllo di integrità dopo is_dir per verificare anche che sia! Is_link, perché altrimenti è possibile eseguire il collegamento simbolico a una cartella esterna che viene quindi eliminata e questo può essere considerato un buco nella sicurezza. Quindi dovresti cambiare is_dir("$dir/$file")inis_dir("$dir/$file") && !is_link("$dir/$file")
— Kira M. Backes
13

Per * nix puoi usare un shell_execper rm -Ro DEL /S folder_nameper Windows.

— ankitjaininfo
fonte
2
che ne dici DEL /S folder_namedi Windows
— ankitjaininfo il
@Gordon RMDIR /S /Q folder_nameè ciò che ha funzionato per me
— Brian Leishman,
2
@ WiR3D fintanto che il comando exec non contiene input da parte dell'utente, dovresti essere bravo. Es .:exec('rm -rf ' . __DIR__ . '/output/*.log');
— Brian Hannay,
5 
<?php

use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use SplFileInfo;

# http://stackoverflow.com/a/3352564/283851
# https://gist.github.com/XzaR90/48c6b615be12fa765898

# Forked from https://gist.github.com/mindplay-dk/a4aad91f5a4f1283a5e2

/**
 * Recursively delete a directory and all of it's contents - e.g.the equivalent of `rm -r` on the command-line.
 * Consistent with `rmdir()` and `unlink()`, an E_WARNING level error will be generated on failure.
 *
 * @param string $source absolute path to directory or file to delete.
 * @param bool   $removeOnlyChildren set to true will only remove content inside directory.
 *
 * @return bool true on success; false on failure
 */
function rrmdir($source, $removeOnlyChildren = false)
{
    if(empty($source) || file_exists($source) === false)
    {
        return false;
    }

    if(is_file($source) || is_link($source))
    {
        return unlink($source);
    }

    $files = new RecursiveIteratorIterator
    (
        new RecursiveDirectoryIterator($source, RecursiveDirectoryIterator::SKIP_DOTS),
        RecursiveIteratorIterator::CHILD_FIRST
    );

    //$fileinfo as SplFileInfo
    foreach($files as $fileinfo)
    {
        if($fileinfo->isDir())
        {
            if(rrmdir($fileinfo->getRealPath()) === false)
            {
                return false;
            }
        }
        else
        {
            if(unlink($fileinfo->getRealPath()) === false)
            {
                return false;
            }
        }
    }

    if($removeOnlyChildren === false)
    {
        return rmdir($source);
    }

    return true;
}
— XzaR
fonte
Suggerimento abbastanza complesso ;-)
— Philipp,
@Philipp sì, credo. Beh, ho fatto un fork di gist.github.com/mindplay-dk/a4aad91f5a4f1283a5e2 perché non l'ho fatto funzionare, quindi ho pensato di poterlo condividere.
— XzaR,
C'è un problema. Non elimina le cartelle vuote dopo aver rimosso tutti i file. Pubblicazione della versione leggermente modificata come risposta di seguito.
— Vladislav Rastrusny il
@Vladislav Rastrusny davvero? Per me funziona. Forse avevi una cartella con sola lettura o qualcosa del genere.
— XzaR
1

codice 'semplice' che funziona e può essere letto da un bambino di dieci anni:

function deleteNonEmptyDir($dir) 
{
   if (is_dir($dir)) 
   {
        $objects = scandir($dir);

        foreach ($objects as $object) 
        {
            if ($object != "." && $object != "..") 
            {
                if (filetype($dir . "/" . $object) == "dir")
                {
                    deleteNonEmptyDir($dir . "/" . $object); 
                }
                else
                {
                    unlink($dir . "/" . $object);
                }
            }
        }

        reset($objects);
        rmdir($dir);
    }
}

Nota che tutto ciò che ho fatto è stato espandere / semplificare e correggere (non ha funzionato per dir non vuoto) la soluzione qui: In PHP come rimuovo ricorsivamente tutte le cartelle che non sono vuote?

— Programster
fonte
1

La soluzione migliorata di @Artefacto - errori di battitura corretti e codice semplificato, funzionante per entrambe le directory - vuota && non vuota.

  function recursive_rmdir($dir) { 
    if( is_dir($dir) ) { 
      $objects = array_diff( scandir($dir), array('..', '.') );
      foreach ($objects as $object) { 
        $objectPath = $dir."/".$object;
        if( is_dir($objectPath) )
          recursive_rmdir($objectPath);
        else
          unlink($objectPath); 
      } 
      rmdir($dir); 
    } 
  }
— jave.web
fonte
1

La soluzione funzionante al 100%

public static function rmdir_recursive($directory, $delete_parent = null)
  {
    $files = glob($directory . '/{,.}[!.,!..]*',GLOB_MARK|GLOB_BRACE);
    foreach ($files as $file) {
      if (is_dir($file)) {
        self::rmdir_recursive($file, 1);
      } else {
        unlink($file);
      }
    }
    if ($delete_parent) {
      rmdir($directory);
    }
  }
— David Pankov
fonte
0

Qualcosa come questo?

function delete_folder($folder) {
    $glob = glob($folder);
    foreach ($glob as $g) {
        if (!is_dir($g)) {
            unlink($g);
        } else {
            delete_folder("$g/*");
            rmdir($g);
        }
    }
}
— K-Gun
fonte
Non riesco a spiegare perché, ma non ha funzionato per me. Continuava a cercare di eliminare una cartella che non era vuota. La seconda risposta sopra ha funzionato bene.
— Laurent,
1
@ buggy3 A quale codice specifico ti riferisci? Il link si collega semplicemente a questa pagina delle domande.
— cgogolin,
0

Esempio con la funzione glob () . Eliminerà tutti i file e le cartelle in modo ricorsivo, inclusi i file che iniziano con punto.

delete_all( 'folder' );

function delete_all( $item ) {
    if ( is_dir( $item ) ) {
        array_map( 'delete_all', array_diff( glob( "$item/{,.}*", GLOB_BRACE ), array( "$item/.", "$item/.." ) ) );
        rmdir( $item );
    } else {
        unlink( $item );
    }
};
— Danijel
fonte
Sono andato consystem('rm -fr folder')
— Itay Moav
0

La funzione unlinkr elimina in modo ricorsivo tutte le cartelle e i file in un determinato percorso assicurandosi che non elimini lo script stesso.

function unlinkr($dir, $pattern = "*") {
    // find all files and folders matching pattern
    $files = glob($dir . "/$pattern"); 

    //interate thorugh the files and folders
    foreach($files as $file){ 
    //if it is a directory then re-call unlinkr function to delete files inside this directory     
        if (is_dir($file) and !in_array($file, array('..', '.')))  {
            echo "<p>opening directory $file </p>";
            unlinkr($file, $pattern);
            //remove the directory itself
            echo "<p> deleting directory $file </p>";
            rmdir($file);
        } else if(is_file($file) and ($file != __FILE__)) {
            // make sure you don't delete the current script
            echo "<p>deleting file $file </p>";
            unlink($file); 
        }
    }
}

se vuoi eliminare tutti i file e le cartelle in cui inserisci questo script, chiamalo come segue

//get current working directory
$dir = getcwd();
unlinkr($dir);

se vuoi eliminare solo i file php, chiamalo come segue

unlinkr($dir, "*.php");

è possibile utilizzare qualsiasi altro percorso per eliminare anche i file 

unlinkr("/home/user/temp");

Ciò eliminerà tutti i file nella directory home / user / temp.

— Tofeeq
fonte
0

Io uso questo codice ...

 function rmDirectory($dir) {
        foreach(glob($dir . '/*') as $file) {
            if(is_dir($file))
                rrmdir($file);
            else
                unlink($file);
        }
        rmdir($dir);
    }

o questo ...

<?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); 
  } 
?>
— Hamed
fonte
Questo è ricorsivo?
— Martin Tournoij,
0

Una volta terminata l'esecuzione dei test, basta rimuovere # da #unlink e #rmdir nella classe. 

<?php 
class RMRFiles {

        function __construct(){
        }

    public function recScan( $mainDir, $allData = array() )
    {

    // hide files
    $hidefiles = array(
    ".",
    "..") ;

    //start reading directory
    $dirContent = scandir( $mainDir ) ;

        //cycle through
        foreach ( $dirContent as $key => $content )
        {
            $path = $mainDir . '/' . $content ;

            // if is readable / file
            if ( ! in_array( $content, $hidefiles ) )
            {
            if ( is_file( $path ) && is_readable( $path ) )
            {
            #delete files within directory
            #unlink($path);
            $allData['unlink'][] = $path ;
            }

            // if is readable / directory
            else
            if ( is_dir( $path ) && is_readable( $path ) )
            {
            /*recursive*/
            $allData = $this->recScan( $path, $allData ) ;

            #finally remove directory
            $allData['rmdir'][]=$path;
            #rmdir($path);
            }
            }
        }

    return $allData ;

    }

}

header("Content-Type: text/plain");

/* Get absolute path of the running script 
Ex : /home/user/public_html/   */
define('ABPATH', dirname(__file__) . '/'); 

/* The folder where we store cache files 
Ex: /home/user/public_html/var/cache   */
define('STOREDIR','var/cache'); 

$rmrf = new RMRFiles();
#here we delete folder content files & directories
print_r($rmrf->recScan(ABPATH.STOREDIR));
#finally delete scanned directory ? 
#rmdir(ABPATH.STOREDIR);

?>
— Alin Razvan
fonte
0 
<?php

/**
 * code by Nk (nk.have.a@gmail.com)
 */

class filesystem
{
    public static function remove($path)
    {
        return is_dir($path) ? rmdir($path) : unlink($path);
    }

    public static function normalizePath($path)
    {
        return $path.(is_dir($path) && !preg_match('@/$@', $path) ? '/' : '');      
    }

    public static function rscandir($dir, $sort = SCANDIR_SORT_ASCENDING)
    {
        $results = array();

        if(!is_dir($dir))
        return $results;

        $dir = self::normalizePath($dir);

        $objects = scandir($dir, $sort);

        foreach($objects as $object)
        if($object != '.' && $object != '..')
        {
            if(is_dir($dir.$object))
            $results = array_merge($results, self::rscandir($dir.$object, $sort));
            else
            array_push($results, $dir.$object);
        }

        array_push($results, $dir);

        return $results;
    }

    public static function rrmdir($dir)
    {
        $files = self::rscandir($dir);

        foreach($files as $file)
        self::remove($file);

        return !file_exists($dir);
    }
}

?>

cleanup.php:

<?php

/* include.. */

filesystem::rrmdir('/var/log');
filesystem::rrmdir('./cache');

?>
— NKC
fonte
0

Sembra che tutte le altre risposte assumano che il percorso assegnato alla funzione sia sempre una directory. Questa variante funziona per rimuovere directory e singoli file:

/**
 * Recursively delete a file or directory.  Use with care!
 *
 * @param string $path
 */
function recursiveRemove($path) {
    if (is_dir($path)) {
        foreach (scandir($path) as $entry) {
            if (!in_array($entry, ['.', '..'])) {
                recursiveRemove($path . DIRECTORY_SEPARATOR . $entry);
            }
        }
        rmdir($path);
    } else {
        unlink($path);
    }
}
— jlh
fonte
0

Utilizzando DirectoryIterator e la ricorsione in modo corretto:

function deleteFilesThenSelf($folder) {
    foreach(new DirectoryIterator($folder) as $f) {
        if($f->isDot()) continue; // skip . and ..
        if ($f->isFile()) {
            unlink($f->getPathname());
        } else if($f->isDir()) {
            deleteFilesThenSelf($f->getPathname());
        }
    }
    rmdir($folder);
}
— AvaLanCS
fonte
-1

Ho appena creato questo codice, da alcune discussioni StackOverflow. Non ho ancora testato su ambiente Linux. È realizzato per eliminare un file o una directory, completamente: 

function splRm(SplFileInfo $i)
{
    $path = $i->getRealPath();

    if ($i->isDir()) {
        echo 'D - ' . $path . '<br />';
        rmdir($path);
    } elseif($i->isFile()) {
        echo 'F - ' . $path . '<br />';
        unlink($path);
    }
}

function splRrm(SplFileInfo $j)
{
    $path = $j->getRealPath();

    if ($j->isDir()) {
        $rdi = new RecursiveDirectoryIterator($path, FilesystemIterator::SKIP_DOTS);
        $rii = new RecursiveIteratorIterator($rdi, RecursiveIteratorIterator::CHILD_FIRST);
        foreach ($rii as $i) {
            splRm($i);
        }
    }
    splRm($j);

}

splRrm(new SplFileInfo(__DIR__.'/../dirOrFileName'));
— Chicna
fonte
-1 
function rmdir_recursive( $dirname ) {

    /**
     * FilesystemIterator and SKIP_DOTS
     */

    if ( class_exists( 'FilesystemIterator' ) && defined( 'FilesystemIterator::SKIP_DOTS' ) ) {

        if ( !is_dir( $dirname ) ) {
            return false;
        }

        foreach( new RecursiveIteratorIterator( new RecursiveDirectoryIterator( $dirname, FilesystemIterator::SKIP_DOTS ), RecursiveIteratorIterator::CHILD_FIRST ) as $path ) {
            $path->isDir() ? rmdir( $path->getPathname() ) : unlink( $path->getRealPath() );
        }

        return rmdir( $dirname );

    }

    /**
     * RecursiveDirectoryIterator and SKIP_DOTS
     */

    if ( class_exists( 'RecursiveDirectoryIterator' ) && defined( 'RecursiveDirectoryIterator::SKIP_DOTS' ) ) {

        if ( !is_dir( $dirname ) ) {
            return false;
        }

        foreach( new RecursiveIteratorIterator( new RecursiveDirectoryIterator( $dirname, RecursiveDirectoryIterator::SKIP_DOTS ), RecursiveIteratorIterator::CHILD_FIRST ) as $path ) {
            $path->isDir() ? rmdir( $path->getPathname() ) : unlink( $path->getRealPath() );
        }

        return rmdir( $dirname );

    }

    /**
     * RecursiveIteratorIterator and RecursiveDirectoryIterator
     */

    if ( class_exists( 'RecursiveIteratorIterator' ) && class_exists( 'RecursiveDirectoryIterator' ) ) {

        if ( !is_dir( $dirname ) ) {
            return false;
        }

        foreach( new RecursiveIteratorIterator( new RecursiveDirectoryIterator( $dirname ), RecursiveIteratorIterator::CHILD_FIRST ) as $path ) {
            if ( in_array( $path->getFilename(), array( '.', '..' ) ) ) {
                continue;
            }
            $path->isDir() ? rmdir( $path->getPathname() ) : unlink( $path->getRealPath() );
        }

        return rmdir( $dirname );

    }

    /**
     * Scandir Recursive
     */

    if ( !is_dir( $dirname ) ) {
        return false;
    }

    $objects = scandir( $dirname );

    foreach ( $objects as $object ) {
        if ( $object === '.' || $object === '..' ) {
            continue;
        }
        filetype( $dirname . DIRECTORY_SEPARATOR . $object ) === 'dir' ? rmdir_recursive( $dirname . DIRECTORY_SEPARATOR . $object ) : unlink( $dirname . DIRECTORY_SEPARATOR . $object );
    }

    reset( $objects );
    rmdir( $dirname );

    return !is_dir( $dirname );

}
— D3F4ULT
fonte
-1

Variante modificata della soluzione @XzaR. Rimuove le cartelle vuote, quando tutti i file vengono eliminati da esse e genera eccezioni invece di restituire false in caso di errori.

function recursivelyRemoveDirectory($source, $removeOnlyChildren = true)
{
    if (empty($source) || file_exists($source) === false) {
        throw new Exception("File does not exist: '$source'");
    }

    if (is_file($source) || is_link($source)) {
        if (false === unlink($source)) {
            throw new Exception("Cannot delete file '$source'");
        }
    }

    $files = new RecursiveIteratorIterator(
        new RecursiveDirectoryIterator($source, RecursiveDirectoryIterator::SKIP_DOTS),
        RecursiveIteratorIterator::CHILD_FIRST
    );

    foreach ($files as $fileInfo) {
        /** @var SplFileInfo $fileInfo */
        if ($fileInfo->isDir()) {
            if ($this->recursivelyRemoveDirectory($fileInfo->getRealPath()) === false) {
                throw new Exception("Failed to remove directory '{$fileInfo->getRealPath()}'");
            }
            if (false === rmdir($fileInfo->getRealPath())) {
                throw new Exception("Failed to remove empty directory '{$fileInfo->getRealPath()}'");
            }
        } else {
            if (unlink($fileInfo->getRealPath()) === false) {
                throw new Exception("Failed to remove file '{$fileInfo->getRealPath()}'");
            }
        }
    }

    if ($removeOnlyChildren === false) {
        if (false === rmdir($source)) {
            throw new Exception("Cannot remove directory '$source'");
        }
    }
}
— Vladislav Rastrusny
fonte
-1 
function deltree_cat($folder)
{
    if (is_dir($folder))
    {
             $handle = opendir($folder);
             while ($subfile = readdir($handle))
             {
                     if ($subfile == '.' or $subfile == '..') continue;
                     if (is_file($subfile)) unlink("{$folder}/{$subfile}");
                     else deltree_cat("{$folder}/{$subfile}");
             }
             closedir($handle);
             rmdir ($folder);
     }
     else
     {
        unlink($folder);
     }
}
— Ilya Yaremchuk
fonte
1
Se stai rispondendo a una vecchia domanda che ha già un numero di risposte tra cui una accettata, devi pubblicare una spiegazione del valore aggiunto dalla tua risposta, non solo del codice. Le risposte solo al codice sono disapprovate in generale, ma soprattutto in questo caso.
— Jared Smith,
Ho votato a favore di questa risposta e ho accettato la risposta. Questo non è male, dal mio controllo del benchmark (senza unlink, rmdir) il opendir+ readdirfunziona più velocemente scandire RecursiveDirectoryIteratorusa anche meno memoria di tutti. Per rimuovere la cartella che devo closedirprima, ero bloccato a questo. Grazie a questa risposta
— V,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.