Delete directory with files in it?

Question

I wonder, what's the easiest way to delete a directory with all its files in it?

I'm using rmdir(PATH . '/' . $value); to delete a folder, however, if there are files inside of it, I simply can't delete it.

Underlying

Just want to note. I created multiple files and if during the process get some error, then need to delete the previously created files. When created files, forgot to use fclose($create_file); and when delete, got Warning: unlink(created_file.xml): Permission denied in.... So to avoid such errors must close created files. – Nonconformity

Answer 1

There are at least two options available nowadays.

1. Before deleting the folder, delete all its files and folders (and this means recursion!). Here is an example:

   function deleteDir(string $dirPath): void {
       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)) {
               deleteDir($file);
           } else {
               unlink($file);
           }
       }
       rmdir($dirPath);
   }
   

2. And if you are using 5.2+ you can use a RecursiveIterator to do it without implementing the recursion yourself:

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

Tom

little add-on :-) glob() does not support files like .htaccess. I used the function to clear directories made by KCFinder (CKEditor plugin) which generates both .htaccess and .thumbs (file + folder). Instead I used the scandir function to get the folder list. Just make sure you filter the '.' and '..' files from the result list. – Hurleigh

DIRECTORY_SEPARATOR is not necessary when you're building paths to send to the os. Windows will accept forward slashes too. Its mainly useful for explode()ing a path taken from the OS. alanhogan.com/tips/php/directory-separator-not-necessary – Jeanajeanbaptiste

The second example still does not always delete all sub-folders. For example I tested on a folder that had several subfolders and files which all also had subfolders and files. After the first run it deleted everything except the top level folder and left and subfolders in it, the subfolders are now empty though. SO I had to refresh the page a few times to get it to delete all the fsubfolders – Diffluent

For the second solution, it doesn't work if you have a lot of sub directories that have their own directories including files. – Arbalest

Please add is_array check to $files variable before using it in a foreach. – Keaton

change your glob impl to "$files = glob($dirPath . '{,.}*', GLOB_BRACE);" and check for dots in last-pos of file-name (and continue those) -> and this method can handle hidden files nicely... thx for the base-impl :) – Firebrat

In addition to @Alix Axel Using here the [SplFileInfo::getRealPath()] (php.net/manual/en/splfileinfo.getrealpath.php) is not a good idea. This method expands all symbolic links, that means, will be deleted a real file from somewhere instead a symlink from the target directory. You should use SplFileInfo::getPathname() instead. – Propst

glob($dirPath . '{,.}[!.,!..]*',GLOB_BRACE) will skips ./ and ../ but keeps dot-files. – Backlog

I agree with @Vijit, use getPathname() instead of getRealPath(). It does the same thing without deleting more than what you are expecting to if symlinks are found. – Bronchiole

First solution doesn't seem to delete hidden files (namely .DS_Store files in macOS), so deleting the directory fails at the end. – Postulant

If you can't execute rmdir() at the end of the second implementation, you could try adding $ri->endIteration(); right before it. – Mastoid

RecursiveDirectoryIterator doesn't require PHP 5.3. But SKIP_DOTS does – Bagdad

Answer 2

I generally use this to delete all files in a folder:

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

And then you can do

rmdir($dirname);

Bowsprit

This doesn't delete folders recursively; it only works if the folder has only regular files in it, all of which have file extensions. – Melisenda

If no recursion is needed this is the best and simpliest answer so far. Thanks! – Christcross

In order to remove all files from a folder, not only the ones with extensions, use glob in the following way: array_map('unlink', glob("$dirname/*")); This still doesn't allow you to delete directories nested in the folder. – Lysimeter

Note that this will remove dot (hidden) files as well. – Margerymarget

To delete folders recursively, just do array_map("unlink", glob("$dirname/*")); array_map("rmdir", glob("$dirname/*")); rmdir($dirname);. – Principium

Answer 3

what's the easiest way to delete a directory with all its files in it?

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

Acupuncture

I hope you're not serious. What happens if $dir is / – Procure

@The exactly the same as with any of the codes above. Isn't it? – Acupuncture

Note that, depending how $dir is generated/provided, you may need to do some additional pre-processing to be safe and to avoid bugs. For example, if $dir might have an unescaped space or semi-colon in it, then there could be undesirable side effects. This is not the case with the answers that use things like rmdir() because it will handle the special characters for you. – Atomism

Windows version: system('rmdir '.escapeshellarg($path).' /s /q'); – Rowles

At the very least you should explain some caveats for such a dangerous answer. $dir needs to be sanitized, it's unix-specific, it relies on something many sysadmins disallow (shelling out a command), etc. This is the "easiest" solution only when very specific conditions are met. – Monticule

@ThePixelDeveloper you shouldn't worry about deleting /, this would only work if you'd lounch the script in command line as root, because in web everything happens as apache user – Succedaneum

security.stackexchange.com/questions/1382/… – Ain

How is this not heavily downvoted? Isn't it bad practice to use system? – Rhymester

@YourCommonSense It's platform dependent, can be insecure (I know you can escape the arguments, but it's still safer to use pure PHP to accomplish this), and hosting companies would have most likely disabled it. – Rhymester

@Rhymester OK fair. Let's call it a niche solution. Personally, I cannot imagine PHP running on any OS other than Linux and I forgot the time I was using a shared hosting. – Acupuncture

@ThePixelDeveloper If your PHP script has access to delete files/folders in root directory, you have serious problems anyway. – Mattress

I like this answer more than the others, it's only problem is the Linux dependency, and for the security problem, it's the caller job to check if it is really the intended directory or not, the function's only job is to delete a directory . – Nolita

perfect one-liner! but because this is OS dependent, it's not universal, thus not preferable for me. – Halliday

thank you do this work in shared host? – Orfinger

$dir is what you let it to be, for those with so many caveats about using this approach. – Cohbath

Answer 4

Short function that does the job:

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

I use it in a Utils class like this:

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

---

With great power comes great responsibility: When you call this function with an empty value, it will delete files starting in root (/). As a safeguard you can check if path is empty:

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

Headwind

The static one doesn't work because $this === NULL when you call a static function on a class. It would work if $this_func = array(__CLASS__, __FUNCTION__); – Kiefer

Can someone explain the line array_map($class_func, glob($path.'/*')) == @rmdir($path)? I guess he's recursing through the subfolders, but what does the == @rmdir part do? How does the <array of booleans> == <boolean> return the answer? Does it check if each return value of the recursion is the same as the boolean on the right? – Kunlun

It's a trick to merge two statements into one statement. This is because ternary operators allow only one statement per argument. array_map(...) removes all files within the directory, @rmdir(...) removes the directory itself. – Headwind

Be careful! This function does not check if the path really exists. If you pass an empty argument, the function will start to delete files starting from the root! Add a sanity check to your path before you run this function. – Photogram

Some people did not see Tatu's comment and recursively deleted /, so I appended a safeguarded version to my post. – Headwind

Sorry but... I still not understanding the operation of the last line with array_map... – Floodgate

@PedroAntônio array_map calls a function (first argument) for each item returned by the glob and then continues to delete the dir itself in @rmdir. – Headwind

Answer 5

As seen in most voted comment on PHP manual page about rmdir() (see http://php.net/manual/es/function.rmdir.php), glob() function does not return hidden files. scandir() is provided as an alternative that solves that issue.

Algorithm described there (which worked like a charm in my case) is:

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

Slug

can you please explain is_dir("$dir/$file") - did not meet with the "$dir/$file" parameter – Hewart

What do you mean? It checks if the entry found in a directory ($file) is a directory or a file. "$dir/$file" is the same as $dir . "/" . $file. – Slug

I honestly did not know you can concatenate variables like this :) thx – Hewart

The only challenge I came across with this example is that it doesn't handle symlinks to directories vary well within the directory. To do this, change the is_dir check to (is_dir("$dir/$file") && !is_link("$dir/$file")) – Helwig

Answer 6

You may use Symfony's Filesystem (code):

// composer require symfony/filesystem

use Symfony\Component\Filesystem\Filesystem;

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

However I couldn't delete some complex directory structures with this method, so first you should try it to ensure it's working properly.

I could delete the said directory structure using a Windows specific implementation:

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

And just for the sake of completeness, here is an old code of mine:

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

Urey

Thanks a lot .you save my time. – Pruinose

"Don't reinvent the wheel". Thank you – Fortyfive

Answer 7

This is a shorter Version works great to me

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

Losing

Answer 8

You can try as follows:

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

Lemmy

The simplicity of the function is beautiful and it works excellently, except on dot files. – Feliciafeliciano

Answer 9

I can't believe there are 30+ answers for this. Recursively deleting a folder in PHP could take minutes depending on the depth of the directory and the number of files in it! You can do this with one line of code ...

shell_exec("rm -rf " . $dir);

If you're concerned with deleting the entire filesystem, make sure your $dir path is exactly what you want first. NEVER allow a user to input something that can directly delete files without first heavily validating the input. That's essential coding practice.

Clotheshorse

I am doing clean up on the /tmp folder so shell_exec("rm -rf " . sys_get_temp_dir() . "/{$dir}"); is easy, straight forward and lighting fast. – Biancabiancha

This! but I would do shell_exec("rm -rf '$dir'"); – Roue

I'm using this with a cron job to remove uploaded security camera images from the previous day. Obviously as stated above don't let users have access to this and make sure you got your $dir correct! – Sismondi

Not everyone has access to shell_exec(), but if you do then this would be the way to go. – Charpoy

Answer 10

This one works for me:

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

Tuning

Answer 11

Here you have one nice and simple recursion for deleting all files in source directory including that directory:

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

}

Function is based on recursion made for copying directory. You can find that function here: Copy entire contents of a directory to another using php

Toddler

Answer 12

The Best Solution for me

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

code:

function my_folder_delete($path) {
    if (in_array($path, ['.', '/'])) return; // ensure to avoid accidents
    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);
    }
}

p.s. REMEMBER!
dont pass EMPTY VALUES to any Directory deleting functions!!! (backup them always, otherwise one day you might get DISASTER!!)

Jelle

Answer 13

Litle bit modify of alcuadrado's code - glob don't see files with name from points like .htaccess so I use scandir and script deletes itself - check __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);
}

Trappist

Answer 14

Glob function doesn't return the hidden files, therefore scandir can be more useful, when trying to delete recursively a tree.

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

Coffey

Answer 15

Example for the Linux server: exec('rm -f -r ' . $cache_folder . '/*');

Lacasse

I usually like to add a sanity check on $cache_folder before running rm -rf to avoid costly mistakes – Quartus

Answer 16

What about this:

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

Kenelm

Answer 17

I want to expand on the answer by @alcuadrado with the comment by @Vijit for handling symlinks. Firstly, use getRealPath(). But then, if you have any symlinks that are folders it will fail as it will try and call rmdir on a link - so you need an extra check.

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

Yan

I don't have enough rep to comment on the answer directly. – Yan

Answer 18

I prefer this because it still returns TRUE when it succeeds and FALSE when it fails, and it also prevents a bug where an empty path might try and delete everything from '/*' !!:

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

Kiefer

Answer 19

Using DirectoryIterator an equivalent of a previous answer…

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

Excited

Answer 20

you can try this simple 12 line of code for delete folder or folder files... happy coding... ;) :)

function deleteAll($str) {
    if (is_file($str)) {
        return unlink($str);
    }
    elseif (is_dir($str)) {
        $scan = glob(rtrim($str,'/').'/*');
        foreach($scan as $index=>$path) {
            $this->deleteAll($path);
        }            
        return @rmdir($str);
    }
}

Ophthalmia

Answer 21

Something like this?

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

Ancell

Answer 22

Delete all files in Folder
array_map('unlink', glob("$directory/*.*"));
Delete all .*-Files in Folder (without: "." and "..")
array_map('unlink', array_diff(glob("$directory/.*),array("$directory/.","$directory/..")))
Now delete the Folder itself
rmdir($directory)

Poland

Answer 23

2 cents to add to THIS answer above, which is great BTW

After your glob (or similar) function has scanned/read the directory, add a conditional to check the response is not empty, or an invalid argument supplied for foreach() warning will be thrown. So...

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

My full function (as an object method):

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

Frodi

Answer 24

Here is the solution that works perfect:

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

Marasco

Answer 25

What about this?

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

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

Lipscomb

Answer 26

You could copy the YII helpers

$directory (string) - to be deleted recursively.

$options (array) - for the directory removal. Valid options are: traverseSymlinks: boolean, whether symlinks to the directories should be traversed too. Defaults to false, meaning that the content of the symlinked directory would not be deleted. Only symlink would be removed in that default case.

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

Trilinear

Answer 27

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

Have your tryed out the obove code from php.net

Work for me fine

Agonistic

Answer 28

For windows:

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

Stepson

Answer 29

Like Playnox's solution, but with the elegant built-in 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!');
  }
 }

Reorder

Answer 30

I do not remember from where I copied this function, but it looks like it is not listed and it is working for me

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

Heimer

Answer 31

Simple and Easy...

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

Getup

Answer 32

If you are not sure, Given path is directory or file then you can use this function to delete path

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

Trolley

Answer 33

A nicely formatted helper function that can be used with a framework like Laravel

if(!function_exists("remove_directory")){
    
   /**
    * remove_directory
    * 
    * Removes all contained files and folders in the directory, then removes
    * itself
    * 
    * 
    * @param {string} $directory
    * 
    */
    function remove_directory(string $directory){

    

        if (!is_dir($directory)) {

            throw new InvalidArgumentException("{$directory} must be a directory");

        }

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

            $directory .= '/';

        }


        $files = glob($directory . '*', GLOB_MARK);


        foreach ($files as $file) {

            if (is_dir($file)) {

                remove_directory($file);

            } else {

                unlink($file);

            }

        }


        rmdir($directory);


    }

}

Flesher

Answer 34

If you happen to be using laravel, then you can simply use the File facade:

use Illuminate\Support\Facades\File;

File::deleteDirectory($pathToDirectory);

Apportion

Answer 35

Here is a simple solution

$dirname = $_POST['d'];
    $folder_handler = dir($dirname);
    while ($file = $folder_handler->read()) {
        if ($file == "." || $file == "..")
            continue;
        unlink($dirname.'/'.$file);

    }
   $folder_handler->close();
   rmdir($dirname);

Armistice

in dirname cant be other dirs, only files, but isnt problem make a little change in my code ;) – Armistice

Using $_POST without any validation ⇒ security breach. – Baez

Answer 36

Platform independent code.

Took the answer from PHP.net

if(PHP_OS === 'Windows')
{
 exec("rd /s /q {$path}");
}
else
{
 exec("rm -rf {$path}");
}

Threephase