這裡主要是進一步使用其他方法刪除目錄，提高自己對fs模組提供的api的熟悉度

非同步刪除（深度模式）

核心思想就是遍歷完成某一個目錄以後，在遍歷另外一個目錄，最後開始冒泡刪除

const fs = require('fs')
const path = require('path')

/**
 *
 * @desc 非同步深度迴圈刪除目錄
 * @param {string} dir 需要刪除的目錄
 * @param {function} callback 回撥函式
 *
 * 實現思路：
 * 1.讀取檔案目錄拿到當前目錄所有的files
 * 2.呼叫next方法，並從0開始遍歷files
 * 3.遍歷結束，呼叫callbanck
 */
 

function rmdir (dir, callback) {
fs.readdir(dir, (err, files) => {
    /**
     * @desc 內部迴圈遍歷使用的工具函式
     * @param {Number} index 表示讀取files的下標
     */
    function next(index) {
        // 如果index 等於當前files的時候說明迴圈遍歷已經完畢，可以刪除dir，並且呼叫callback
        if (index == files.length) return fs.rmdir(dir, callback)
        // 如果檔案還沒有遍歷結束的話，繼續拼接新路徑，使用fs.stat讀取該路徑
 

        let newPath = path.join(dir, files[index])
        // 讀取檔案，判斷是檔案還是檔案目錄

        fs.stat(newPath, (err, stat) => {
            if (stat.isDirectory() ) {
                // 因為我們這裡是深度迴圈，也就是說遍歷玩files[index]的目錄以後，才會去遍歷files[index+1]
                // 所以在這裡直接繼續呼叫rmdir，然後把迴圈下一個檔案的呼叫放在當前呼叫的callback中
 

                rmdir(newPath, () => next(index+1))
            } else {
                // 如果是檔案，則直接刪除該檔案，然後在回撥函式中呼叫遍歷nextf方法，並且index+1傳進去
                fs.unlink(newPath, () => next(index+1))
            }
        })
    }
    next(0)
})
}

 rmdir('a', () => {console.log('檔案刪除完畢')})

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44

同步刪除目錄(廣度模式)

核心思想：遍歷目錄，把所有的路徑都放入一個程式池，然後迴圈刪除所有檔案

/**
 * 廣度遍歷刪除檔案
 */
const fs = require('fs')
const path = require('path')
/**
 * @desc 同步廣度刪除
 * @param {string} dir 需要刪除的目錄
 *
 * 實現思路
 * 1.建立需要的變數，arr=> 儲存所有的路徑的檔案池 current => 當前遍歷到的路徑 index => 記錄比遍歷的下標
 * 2.使用while迴圈，拿到所有的路徑
 * 3.使用fs.stat判斷，如果當前路徑是一個目錄，使用fs.readdirSync 讀取所有檔案內容，
 * 4.使用map函式對映files路經(拼接當前遍歷到的carrent和file),
 * 5.新增到檔案池中去
 */
function rmdir(dir) {
    let arr = [dir]
    let current = null
    let index = 0

    while(current = arr[index++]) {
        // 讀取當前檔案，並做一個判斷，檔案目錄分別處理
        let stat = fs.statSync(current)
        //如果檔案是目錄
        if (stat.isDirectory()) {
            //讀取當前目錄，拿到所有檔案
            let files = fs.readdirSync(current)
            // 將檔案新增到檔案池
            arr = [...arr, ...files.map(file => path.join(current, file))]
        }
    }
    //遍歷刪除檔案
    for (var i = arr.length - 1; i >= 0; i--) {
        // 讀取當前檔案，並做一個判斷，檔案目錄分別處理
        let stat = fs.statSync(arr[i])
        // 目錄和檔案的刪除方法不同
        if (stat.isDirectory()) {
            fs.rmdirSync(arr[i])
        } else {
            fs.unlinkSync(arr[i])
        }
    }
}

rmdir('a')

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47

廣度刪除（非同步呼叫）

實現思路和同步模式一樣，只是講呼叫方式改成了非同步

/**
 * 廣度遍歷刪除檔案 非同步刪除檔案
 */
const fs = require('fs')
const path = require('path')

/**
 * @desc 廣度遍歷刪除檔案目錄
 * @param {String}     需要刪除的目錄
 * @param {FUnction}   任務完成以後執行的回撥函式
 * 
 * 實現思路：
 * 1.建立檔案池（arr），建立一個current物件，遍歷的時候使用
 * 2.建立一個next方法，遍歷查詢檔案和讀取檔案目錄使用
 * 3.建立一個rm方法，主要用來刪除檔案
 */
function rmdir (dir, callback) {
    var arr = [dir] //檔案池，儲存所有的檔案
    var current = null //遍歷檔案的時候儲存臨時檔案

    /**
     * 
     * @param {Number} index 表示遍歷檔案池的下標 
     */
    function next (index) {
        current = arr[index] //拿到當前遍歷的值
        if (!current) return rm(index-1) //判斷是否為空，為空的話說明已經遍歷結束，開始刪除檔案
        //遍歷刪除所有檔案和目錄
        //讀取檔案，對檔案和檔案目錄進行不同的操作
        fs.stat(current, (err, stat) => {
            if (stat.isDirectory()) {
                //如果是檔案目錄就讀取檔案目錄的內容
                fs.readdir(current, (err, files) => {
                    //映射出新的路徑，然後新增到檔案池
                   var temp = files.map( file => path.join(current, file))
                    arr = [...arr, ...temp]
                    //遍歷檔案池下一個檔案
                    next(index+1)
                })
            } else {
                //如果是檔案，則直接遍歷檔案池下一個檔案
                next(index+1)
            }
        })

        /**
         * @desc 刪除目錄方法
         * @param {Number} index 需要刪除的檔案的標，
         * 
         * 實現思路：
         * 1.通過index拿到當前需要刪除的檔案[檔案目錄]，判斷是否為空，為空就直接清空檔案池，呼叫callback
         * 2.如果不為空，則使用fs.stat讀取檔案，檢視是檔案還是檔案目錄，
         * 3.呼叫不同的方法刪除該檔案,並且呼叫自身，index在-1以後傳入
         * 
         */
        function rm (index) {
            current = arr[index]
            //如果為空，說明檔案刪除完畢，呼叫callback
            if (!current) {
                arr = null;
                return callback && callback()
            }
            //如果檔案不為空，則讀取檔案型別，然後呼叫不同的方法刪除檔案[檔案目錄]
            fs.stat(current, (err, stat) => {
                if (stat.isDirectory()) {
                    fs.rmdir(current, err => rm(index-1))
                } else {
                    fs.unlink(current, err => rm(index-1))
                }
            })
        }
    }
    //第一次開始遍歷檔案目錄
    next(0)
}
rmdir('a', ()=>{console.log('檔案刪除完畢')})

function deleteFolderRecursive(path) {
    if( fs.existsSync(path) ) {
        fs.readdirSync(path).forEach(function(file) {
            var curPath = path + "/" + file;
            if(fs.statSync(curPath).isDirectory()) { // recurse
                deleteFolderRecursive(curPath);
            } else { // delete file
                fs.unlinkSync(curPath);
            }
        });
        fs.rmdirSync(path);
    }
};