Supprimer tous les fichiers d'un dossier en utilisant PHP?

Par exemple, j'avais un dossier appelé «Temp» et je voulais supprimer ou vider tous les fichiers de ce dossier en utilisant PHP. Puis-je faire ça?

$files = glob('path/to/temp/*'); // get all file names
foreach($files as $file){ // iterate files
  if(is_file($file))
    unlink($file); // delete file
}

Si vous souhaitez supprimer des fichiers «cachés» comme .htaccess, vous devez utiliser

$files = glob('path/to/temp/{,.}*', GLOB_BRACE);

Si vous voulez supprimer tout du dossier (y compris les sous - dossiers) utiliser cette combinaison de array_map, unlinket glob:

array_map( 'unlink', array_filter((array) glob("path/to/temp/*") ) );

Cet appel peut également gérer des répertoires vides (merci pour l'astuce, @mojuba!)

Voici une approche plus moderne utilisant la bibliothèque PHP standard (SPL) .

$dir = "path/to/directory";
$di = new RecursiveDirectoryIterator($dir, FilesystemIterator::SKIP_DOTS);
$ri = new RecursiveIteratorIterator($di, RecursiveIteratorIterator::CHILD_FIRST);
foreach ( $ri as $file ) {
    $file->isDir() ?  rmdir($file) : unlink($file);
}
return true;

foreach (new DirectoryIterator('/path/to/directory') as $fileInfo) {
    if(!$fileInfo->isDot()) {
        unlink($fileInfo->getPathname());
    }
}

Ce code de http://php.net/unlink :

/**
 * Delete a file or recursively delete a directory
 *
 * @param string $str Path to file or directory
 */
function recursiveDelete($str) {
    if (is_file($str)) {
        return @unlink($str);
    }
    elseif (is_dir($str)) {
        $scan = glob(rtrim($str,'/').'/*');
        foreach($scan as $index=>$path) {
            recursiveDelete($path);
        }
        return @rmdir($str);
    }
}

$dir = 'your/directory/';
foreach(glob($dir.'*.*') as $v){
    unlink($v);
}

Voir readdir et unlink .

<?php
    if ($handle = opendir('/path/to/files'))
    {
        echo "Directory handle: $handle\n";
        echo "Files:\n";

        while (false !== ($file = readdir($handle)))
        {
            if( is_file($file) )
            {
                unlink($file);
            }
        }
        closedir($handle);
    }
?>

En supposant que vous ayez un dossier avec BEAUCOUP de fichiers en les lisant tous, puis en les supprimant en deux étapes, ce n'est pas si performant. Je pense que la façon la plus efficace de supprimer des fichiers est d'utiliser simplement une commande système.

Par exemple sur Linux j'utilise:

exec('rm -f '. $absolutePathToFolder .'*');

Ou ceci si vous voulez une suppression récursive sans avoir besoin d'écrire une fonction récursive

exec('rm -f -r '. $absolutePathToFolder .'*');

les mêmes commandes existent pour tout OS supporté par PHP. Gardez à l'esprit qu'il s'agit d'une manière PERFORMANTE de supprimer des fichiers. $ absoluePathToFolder DOIT être vérifié et sécurisé avant d'exécuter ce code et des autorisations doivent être accordées.

Le moyen le plus simple et le meilleur pour supprimer tous les fichiers d'un dossier en PHP

$files = glob('my_folder/*'); //get all file names
foreach($files as $file){
    if(is_file($file))
    unlink($file); //delete file
}

J'ai obtenu ce code source d'ici - http://www.codexworld.com/delete-all-files-from-folder-using-php/

Une autre solution: cette classe supprime tous les fichiers, sous-répertoires et fichiers des sous-répertoires.

class Your_Class_Name {
    /**
     * @see http://php.net/manual/de/function.array-map.php
     * @see http://www.php.net/manual/en/function.rmdir.php 
     * @see http://www.php.net/manual/en/function.glob.php
     * @see http://php.net/manual/de/function.unlink.php
     * @param string $path
     */
    public function delete($path) {
        if (is_dir($path)) {
            array_map(function($value) {
                $this->delete($value);
                rmdir($value);
            },glob($path . '/*', GLOB_ONLYDIR));
            array_map('unlink', glob($path."/*"));
        }
    }
}

La fonction unlinkr supprime récursivement tous les dossiers et fichiers d'un chemin donné en s'assurant qu'elle ne supprime pas le script lui-même.

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

si vous souhaitez supprimer tous les fichiers et dossiers dans lesquels vous placez ce script, appelez-le comme suit

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

si vous voulez simplement supprimer uniquement les fichiers php, appelez-le comme suit

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

vous pouvez également utiliser tout autre chemin pour supprimer les fichiers

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

Cela supprimera tous les fichiers du répertoire home / user / temp.

Publié une classe de gestion de fichiers et de dossiers à usage général pour copier, déplacer, supprimer, calculer la taille, etc., qui peut gérer un seul fichier ou un ensemble de dossiers.

https://gist.github.com/4689551

Utiliser:

Pour copier (ou déplacer) un seul fichier ou un ensemble de dossiers / fichiers:

$files = new Files();
$results = $files->copyOrMove('source/folder/optional-file', 'target/path', 'target-file-name-for-single-file.only', 'copy');

Supprimez un seul fichier ou tous les fichiers et dossiers d'un chemin:

$files = new Files();
$results = $files->delete('source/folder/optional-file.name');

Calculez la taille d'un seul fichier ou d'un ensemble de fichiers dans un ensemble de dossiers:

$files = new Files();
$results = $files->calculateSize('source/folder/optional-file.name');

 <?
//delete all files from folder  & sub folders
function listFolderFiles($dir)
{
    $ffs = scandir($dir);
    echo '<ol>';
    foreach ($ffs as $ff) {
        if ($ff != '.' && $ff != '..') {
            if (file_exists("$dir/$ff")) {
                unlink("$dir/$ff");
            }
            echo '<li>' . $ff;
            if (is_dir($dir . '/' . $ff)) {
                listFolderFiles($dir . '/' . $ff);
            }
            echo '</li>';
        }
    }
    echo '</ol>';
}
$arr = array(
    "folder1",
    "folder2"
);
for ($x = 0; $x < count($arr); $x++) {
    $mm = $arr[$x];
    listFolderFiles($mm);
}
//end
?> 

Pour moi, la solution readdirétait la meilleure et fonctionnait comme un charme. Avec glob, la fonction échouait avec certains scénarios.

// Remove a directory recursively
function removeDirectory($dirPath) {
    if (! is_dir($dirPath)) {
        return false;
    }

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

    if ($handle = opendir($dirPath)) {

        while (false !== ($sub = readdir($handle))) {
            if ($sub != "." && $sub != ".." && $sub != "Thumb.db") {
                $file = $dirPath . $sub;

                if (is_dir($file)) {
                    removeDirectory($file);
                } else {
                    unlink($file);
                }
            }
        }

        closedir($handle);
    }

    rmdir($dirPath);
}

J'ai mis à jour la réponse de @Stichoza pour supprimer les fichiers via les sous-dossiers.

function glob_recursive($pattern, $flags = 0) {
    $fileList = glob($pattern, $flags);
    foreach (glob(dirname($pattern).'/*', GLOB_ONLYDIR|GLOB_NOSORT) as $dir) {
        $subPattern = $dir.'/'.basename($pattern);
        $subFileList = glob_recursive($subPattern, $flags);
        $fileList = array_merge($fileList, $subFileList);
    }
    return $fileList;
}

function glob_recursive_unlink($pattern, $flags = 0) {
    array_map('unlink', glob_recursive($pattern, $flags));
}

public static function recursiveDelete($dir)
{
    foreach (new \DirectoryIterator($dir) as $fileInfo) {
        if (!$fileInfo->isDot()) {
            if ($fileInfo->isDir()) {
                recursiveDelete($fileInfo->getPathname());
            } else {
                unlink($fileInfo->getPathname());
            }
        }
    }
    rmdir($dir);
}

Il y a un paquet appelé "Pusheh". En l'utilisant, vous pouvez effacer un répertoire ou supprimer complètement un répertoire ( lien Github ). Il est également disponible sur Packagist .

Par exemple, si vous souhaitez effacer le Temprépertoire, vous pouvez faire:

Pusheh::clearDir("Temp");

// Or you can remove the directory completely
Pusheh::removeDirRecursively("Temp");

Si vous êtes intéressé, consultez le wiki .