इसमें फ़ाइलों के साथ निर्देशिका हटाएं?

Question

मुझे आश्चर्य है कि, इसमें अपनी सभी फ़ाइलों के साथ एक निर्देशिका को हटाने का सबसे आसान तरीका क्या है?

मैं rmdir(PATH . '/' . $value);एक फ़ोल्डर को हटाने के लिए उपयोग कर रहा हूं , हालांकि, अगर इसके अंदर फाइलें हैं, तो मैं बस इसे हटा नहीं सकता।

Comments

डुप्लिकेट के संभावित डुप्लिकेट मैं PHP में एक निर्देशिका और इसकी संपूर्ण सामग्री (फाइलें + उप डायर)

— आर्टीफैक्टो

हाँ, उस सवाल में बिल्कुल जवाब दिया।

— टिमदेव

बस ध्यान देना चाहता हूँ। मैंने कई फाइलें बनाईं और यदि प्रक्रिया के दौरान कुछ त्रुटि हो जाती है, तो पहले बनाई गई फाइलों को हटाने की जरूरत है। जब फ़ाइलें बनाई जाती हैं, तो उपयोग करना भूल जाते हैं fclose($create_file);और जब हटा दिया जाता है, तो Warning: unlink(created_file.xml): Permission denied in...। तो ऐसी त्रुटियों से बचने के लिए बनाई गई फ़ाइलों को बंद करना होगा।

— एंड्रीस

संभावित डुप्लिकेट कैसे मैं पुन: PHP में एक निर्देशिका और इसकी संपूर्ण सामग्री (फ़ाइलें + उप dirs) को हटा सकता हूं?

— फिफी

Answer 1

आजकल कम से कम दो विकल्प उपलब्ध हैं।

1. फ़ोल्डर को हटाने से पहले, इसकी सभी फ़ाइलों और फ़ोल्डरों को हटा दें (और इसका अर्थ है पुनरावृत्ति!)। यहाँ एक उदाहरण है:

   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. और यदि आप 5.2+ का उपयोग कर रहे हैं, तो आप रिकर्सिवेटर का उपयोग खुद को पुनरावृत्ति को लागू किए बिना करने के लिए कर सकते हैं:

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

Comments

आपका दूसरा कार्यान्वयन कुछ खतरनाक है: यह डॉट्स ( .और ..) के लिए जांच नहीं करता है और यह हल किए गए पथ को हटाता है, वास्तविक नहीं।

— एलिक्स एक्सल

थोड़ा ऐड-ऑन :-) ग्लोब () .htaccess जैसी फाइलों का समर्थन नहीं करता है। मैंने KCFinder (CKEditor plugin) द्वारा बनाई गई निर्देशिकाओं को साफ़ करने के लिए फ़ंक्शन का उपयोग किया है जो कि .htaccess और .thumbs (फ़ाइल + फ़ोल्डर) दोनों उत्पन्न करता है। इसके बजाय मैंने scandirफ़ोल्डर सूची प्राप्त करने के लिए फ़ंक्शन का उपयोग किया । बस सुनिश्चित करें कि आप 'फ़िल्टर करें।' और '..' परिणाम सूची से फाइलें।

— जोशुआ - पेन्डो

जब आप ओएस को भेजने के लिए पथ का निर्माण कर रहे हों, तो DIRECTORY_SEPARATOR आवश्यक नहीं है । विंडोज आगे स्लैश भी स्वीकार करेगा। इसका मुख्य रूप से OS से लिए explode()गए पथ के लिए उपयोगी है । alanhogan.com/tips/php/directory-separator-not-n जरूरी

— ReactiveRaven

@Alix Axel का उपयोग करने के अलावा यहाँ [SplFileInfo :: getRealPath ()] ( php.net/manual/en/splfileinfo.getrealpath.php ) एक अच्छा विचार नहीं है। यह विधि सभी प्रतीकात्मक लिंक का विस्तार करती है, इसका मतलब है कि लक्ष्य निर्देशिका से सिमिलिंक के बजाय कहीं से एक वास्तविक फ़ाइल हटा दी जाएगी। आपको इसके बजाय SplFileInfo :: getPathname () का उपयोग करना चाहिए।

— विजित

मैं @ विजित से सहमत हूं, getRealPath () के बजाय getPathname () का उपयोग करें। यह वही काम करता है, जो सिम्बलिंक मिलने पर आप उम्मीद नहीं कर सकते हैं।

— जोमो १

Answer 2

मैं आमतौर पर एक फ़ोल्डर में सभी फ़ाइलों को हटाने के लिए इसका उपयोग करता हूं:

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

और फिर आप कर सकते हैं

rmdir($dirname);

Comments

यह पुनरावर्ती रूप से फ़ोल्डरों को हटाता नहीं है; यह केवल तभी काम करता है जब फ़ोल्डर में केवल नियमित फ़ाइलें होती हैं, जिनमें से सभी में फ़ाइल एक्सटेंशन होते हैं।

— mgnb

यदि कोई पुनरावृत्ति की आवश्यकता नहीं है तो यह अब तक का सबसे अच्छा और सरल उत्तर है। धन्यवाद!

— आईसबेहर

फ़ोल्डर से सभी फ़ाइलों को हटाने के लिए , न केवल एक्सटेंशन वाले, निम्न तरीके से ग्लोब का उपयोग करें: array_map('unlink', glob("$dirname/*"));यह अभी भी आपको फ़ोल्डर में निहित निर्देशिकाओं को हटाने की अनुमति नहीं देता है।

— क्रेमुवा

ध्यान दें कि यह डॉट (छिपी) फ़ाइलों को भी हटा देगा।

— BadHorsie

Answer 3

एक निर्देशिका को डिलीट करने का सबसे आसान तरीका क्या है कि इसमें सभी फाइलें हैं?

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

Comments

मुझे आशा है कि आप गंभीर नहीं हैं। $ Dir होने पर क्या होता है

— Pixel Developer

@ ऊपर दिए गए किसी भी कोड की तरह ही। है ना?

— आपका कॉमन सेंस

ध्यान दें कि कैसे $dirउत्पन्न / प्रदान किया जाता है, इसके आधार पर , आपको सुरक्षित रहने और बग से बचने के लिए कुछ अतिरिक्त पूर्व-प्रसंस्करण करने की आवश्यकता हो सकती है। उदाहरण के लिए, यदि $dirइसमें एक खाली स्थान या अर्ध-बृहदान्त्र हो सकता है, तो अवांछनीय दुष्प्रभाव हो सकते हैं। यह उन उत्तरों के साथ नहीं है जो चीजों का उपयोग करते हैं rmdir()क्योंकि यह आपके लिए विशेष वर्णों को संभालेंगे।

— ट्रॉट

विंडोज संस्करण:system('rmdir '.escapeshellarg($path).' /s /q');

— साइफ्रे

@ ThePelelDeveloper आपको हटाने के बारे में चिंता नहीं करनी चाहिए /, यह केवल तभी काम करेगा जब आप स्क्रिप्ट को कमांड लाइन में रूट के रूप में बताएंगे, क्योंकि वेब में सब कुछ अपाचे उपयोगकर्ता के रूप में होता है

— बेन

Answer 4

लघु कार्य जो कार्य करता है:

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

मैं इसे इस तरह एक यूटिल्स वर्ग में उपयोग करता हूं:

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

---

महान शक्ति के साथ बड़ी जिम्मेदारी आती है : जब आप इस फ़ंक्शन को एक खाली मान के साथ कहते हैं, तो यह रूट ( /) में शुरू होने वाली फ़ाइलों को हटा देगा । एक सुरक्षा के रूप में आप जांच सकते हैं कि क्या रास्ता खाली है:

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

Comments

स्थैतिक एक काम नहीं करता है क्योंकि यह $ === NULL तब होता है जब आप किसी क्लास पर स्टेटिक फंक्शन कहते हैं। यह काम करेगा अगर$this_func = array(__CLASS__, __FUNCTION__);

— मैट कोनॉली

क्या कोई रेखा को समझा सकता है array_map($class_func, glob($path.'/*')) == @rmdir($path)? मुझे लगता है कि वह सबफ़ोल्डर्स के माध्यम से भर्ती कर रहा है, लेकिन क्या == @ श्रीधर भाग करता है? बूलियन का <सरणी> == <बूलियन> जवाब कैसे देता है? क्या यह जाँच करता है कि रिकर्स का प्रत्येक रिटर्न मान दाईं ओर बूलियन के समान है?

— अरविमन

यह दो बयानों को एक बयान में विलय करने की एक चाल है। ऐसा इसलिए है क्योंकि टर्नरी ऑपरेटर प्रति तर्क केवल एक बयान की अनुमति देते हैं। array_map(...)निर्देशिका के भीतर सभी फ़ाइलों @rmdir(...)को हटाता है, निर्देशिका को ही हटाता है।

— ब्लेज़ ise

सावधान रहे! यह फ़ंक्शन चेक नहीं करता है कि क्या पथ वास्तव में मौजूद है। यदि आप एक खाली तर्क पास करते हैं, तो फ़ंक्शन रूट से शुरू होने वाली फ़ाइलों को हटाना शुरू कर देगा! इस फ़ंक्शन को चलाने से पहले अपने पथ पर एक पवित्रता जोड़ें।

— तातु उलेमेन

कुछ लोगों ने तातु की टिप्पणी को नहीं देखा और फिर से हटा दिया गया /, इसलिए मैंने अपनी पोस्ट में एक सुरक्षित संस्करण जोड़ा।

— Blaise

Answer 5

जैसा कि PHP मेनुअल पेज के बारे में सबसे अधिक देखी गई टिप्पणी में देखा गया है rmdir()( http://php.net/manual/es/function.rmdir.php देखें ), glob()फ़ंक्शन छिपी हुई फ़ाइलों को वापस नहीं करता है। scandir()एक विकल्प के रूप में प्रदान किया जाता है जो उस समस्या को हल करता है।

वहाँ वर्णित एल्गोरिथ्म (जो मेरे मामले में एक आकर्षण की तरह काम करता है) है:

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

Comments

क्या आप कृपया बता सकते हैं is_dir ("$ dir / $ फ़ाइल") - "$ dir / $ फ़ाइल" पैरामीटर के साथ नहीं मिला

— इगोर एल।

आपका क्या अर्थ है? यह जाँचता है कि निर्देशिका में पाया गया प्रविष्टि ( $file) एक निर्देशिका या फ़ाइल है। "$dir/$file"के रूप में ही है $dir . "/" . $file।

— जर्मन लैटरे

मैं ईमानदारी से नहीं जानता था कि आप इस तरह से चर को समेट सकते हैं :) thx

— इगोर एल।

Answer 6

यह एक छोटा संस्करण है जो मेरे लिए बहुत अच्छा काम करता है

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

Answer 7

आप सिम्फनी के फाइलसिस्टम ( कोड ) का उपयोग कर सकते हैं :

// composer require symfony/filesystem

use Symfony\Component\Filesystem\Filesystem;

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

हालाँकि मैं इस पद्धति के साथ कुछ जटिल निर्देशिका संरचनाओं को नहीं हटा सका, इसलिए पहले आपको यह सुनिश्चित करने के लिए प्रयास करना चाहिए कि यह ठीक से काम कर रहा है।

मैं विंडोज विशिष्ट कार्यान्वयन का उपयोग करके उक्त निर्देशिका संरचना को हटा सकता हूं:

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

और पूर्णता के लिए, यहाँ मेरा एक पुराना कोड है:

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

Comments

बहुत बहुत धन्यवाद। तुम मेरा समय बचाओ।

— ज़रीफ़ खान

"पहिया को सुदृढ़ मत करो" । धन्यवाद

— Kamafeather

Answer 8

यहाँ आपके पास उस निर्देशिका सहित स्रोत निर्देशिका में सभी फ़ाइलों को हटाने के लिए एक अच्छा और सरल पुनरावर्तन है:

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

}

फ़ंक्शन निर्देशिका की प्रतिलिपि बनाने के लिए बनाई गई पुनरावृत्ति पर आधारित है। आप उस फ़ंक्शन को यहां पा सकते हैं: किसी निर्देशिका की संपूर्ण सामग्री को php का उपयोग करके दूसरे में कॉपी करें

Answer 9

मेरे लिए सबसे अच्छा समाधान

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

कोड:

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

पी एस याद!
किसी भी निर्देशिका को हटाने कार्यों के लिए एम्प्टी वैल्यू पास न करें !!! (उन्हें हमेशा बैकअप दें, अन्यथा एक दिन आपको डिस्चार्ज मिल सकता है !!)

Answer 10

इस बारे में क्या:

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

Answer 11

ग्लोब फ़ंक्शन छिपी हुई फ़ाइलों को वापस नहीं करता है, इसलिए स्कैंडिर अधिक उपयोगी हो सकता है, जब पुनरावर्ती पेड़ को हटाने की कोशिश कर रहा हो।

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

Answer 12

आप निम्नानुसार कोशिश कर सकते हैं:

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

Answer 13

मैं इसे पसंद करता हूं क्योंकि यह अभी भी TRUE देता है जब यह सफल होता है और FALSE जब यह विफल होता है, और यह एक बग को भी रोकता है जहां एक खाली रास्ता कोशिश कर सकता है और '/ *' से सब कुछ हटा सकता है !!:

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

Answer 14

मैं सहानुभूति से निपटने के लिए @Vijit द्वारा टिप्पणी के साथ @alcuadrado द्वारा जवाब पर विस्तार करना चाहता हूं। सबसे पहले, getRealPath () का उपयोग करें। लेकिन फिर, यदि आपके पास कोई सहानुभूति है जो फ़ोल्डर हैं तो यह विफल हो जाएगा क्योंकि यह लिंक पर rmdir को कॉल करने और कॉल करने की कोशिश करेगा - इसलिए आपको एक अतिरिक्त चेक की आवश्यकता है।

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

Comments

मेरे पास सीधे उत्तर पर टिप्पणी करने के लिए पर्याप्त प्रतिनिधि नहीं है।

— user701152

Answer 15

DirectoryIterator का उपयोग करके पिछले उत्तर के बराबर…

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

Answer 16

यह एक मेरे लिए काम करता है:

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

Answer 17

कुछ इस तरह?

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

Answer 18

लिट्ल बिट अल्कुआड्राडो के कोड को संशोधित करता है - globबिंदुओं के नाम के साथ फाइल न देखें, .htaccessइसलिए मैं स्कैंडिर का उपयोग करता हूं और स्क्रिप्ट खुद को हटा देता है - जांच __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);
}

Answer 19

लिनक्स सर्वर के लिए उदाहरण: exec('rm -f -r ' . $cache_folder . '/*');

Comments

मैं आमतौर पर महँगी गलतियों से बचने के लिए rm -rf चलाने से पहले $ cache_folder पर एक स्वच्छता जाँच जोड़ना पसंद करता हूँ

— ग्लिफ

Answer 20

Folder Delete की सभी फाइलें
array_map('unlink', glob("$directory/*.*"));
डिलीट करें। * - Folder में फाइलें (बिना: ""। "और" .. ")
array_map('unlink', array_diff(glob("$directory/.*),array("$directory/.","$directory/..")))
अब फाइल्स को ही डिलीट करें
rmdir($directory)

Answer 21

ऊपर दिए गए THIS उत्तर में जोड़ने के लिए 2 सेंट , जो कि महान BTW है

आपके ग्लोब (या समान) फ़ंक्शन ने निर्देशिका को स्कैन / पढ़ने के बाद, प्रतिक्रिया को खाली नहीं करने के लिए एक सशर्त जोड़ें, या invalid argument supplied for foreach()चेतावनी को फेंक दिया जाएगा। इसलिए...

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

मेरा पूरा कार्य (एक वस्तु विधि के रूप में):

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

Answer 22

यहाँ समाधान है कि सही काम करता है:

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

Answer 23

आप YII सहायकों की प्रतिलिपि बना सकते हैं

$ निर्देशिका (स्ट्रिंग) - पुनरावर्ती रूप से हटाने के लिए।

$ विकल्प (सरणी) - निर्देशिका को हटाने के लिए। मान्य विकल्प हैं: traverseSymlinks: बूलियन, चाहे निर्देशिकाओं के लिए सहानुभूति भी ट्रैवर्स की जाए। करने के लिए चूक false, जिसका अर्थ है कि सहानुभूति निर्देशिका की सामग्री को हटाया नहीं जाएगा। उस डिफ़ॉल्ट मामले में केवल सहानुभूति निकाली जाएगी।

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

Answer 24

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

क्या आपने php.net से obove कोड को आज़माया है

मेरे लिए ठीक काम करो

Answer 25

विंडोज के लिए:

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

Answer 26

Playnox के समाधान की तरह, लेकिन सुरुचिपूर्ण अंतर्निहित 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!');
  }
 }

Answer 27

मुझे याद नहीं है कि मैंने इस फ़ंक्शन को कहां से कॉपी किया है, लेकिन ऐसा लगता है कि यह सूचीबद्ध नहीं है और यह मेरे लिए काम कर रहा है

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

Answer 28

सरल और आसान ...

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

Answer 29

इस बारे में क्या?

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

Answer 30

यदि आप निश्चित नहीं हैं, तो मार्ग दिया गया है निर्देशिका या फ़ाइल तो आप पथ को हटाने के लिए इस फ़ंक्शन का उपयोग कर सकते हैं

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