Nodejs之目录操作

fs.unlink

删除文件

fs.mkdir

删除目录

fs.rmdir

创建目录

fs.readdir

读取儿子级别的目录

fs.stat

fs.stat 获取文件的状态信息， isFile() isDirectory()

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

fs.stat(path.resolve(__dirname, 'a'), function (err, statObj) {
    if (statObj.isFile()) {
        fs.unlink(path.resolve(__dirname, 'c'), () => { })
    } else {
        fs.readdir(path.resolve(__dirname, 'a'), function (err,dir) {
        })
    }
})

删除目录

同步

function rmdirSync(directory) {
    const statObj = fs.statSync(path.resolve(__dirname, directory))
    if (statObj.isFile()) { // 文件是直接移除，目录需要读取儿子
        fs.unlinkSync(directory)
    } else {
        let dirs = fs.readdirSync(directory)
        // 递归删除, 如果是文件夹则递归删除，文件直接删除
        dirs = dirs.map(item => rmdirSync(path.join(directory, item)));
        fs.rmdirSync(directory)
    }
}
rmdirSync('a'); // 同步删除

异步

如果是异步的话如何删除， 树， 树的遍历方式有2种 （层序遍历，深度遍历（先序、后，中））

// 串行删除，index++ 有顺序，浪费性能
function rmdir(directory,callback) {
    fs.stat(directory, (err,statObj) => {
        if (statObj.isFile()) {
            fs.unlink(directory,callback)
        } else {
            fs.readdir(directory, (err,dirs) => {
                dirs = dirs.map(item => path.join(directory, item));
                let index = 0;
                function next() {
                    if (dirs.length === index) { // 儿子删除完毕后删除自己
                        return fs.rmdir(directory,callback)
                    }
                    let dir = dirs[index++];
                    // 先删除第一个 ，将下一个删除操作传入进去
                    rmdir(dir, next);
                }
                next();
            })
        }
    })
}

// 并发删除，性能略好
function rmdir(directory, callback) {
    fs.stat(directory, (err, statObj) => {
        if (statObj.isFile()) {
            fs.unlink(directory, callback)
        } else {
            fs.readdir(directory, (err, dirs) => {
                if (dirs.length === 0) return fs.rmdir(directory, callback)
                dirs = dirs.map(item => path.join(directory, item));
                let index = 0;
                function done() {
                    if (++index === dirs.length) {
                        fs.rmdir(directory, callback)
                    }
                }
                dirs.forEach(dir => rmdir(dir, done))
            })
        }
    })
}

// promise处理
function rmdir(directory) {
    return new Promise((resolve, reject) => {
        fs.stat(directory, (err, statObj) => {
            if (statObj.isFile()) {
                fs.unlink(directory, resolve)
            } else {
                fs.readdir(directory, (err, dirs) => {
                    dirs = dirs.map(item => rmdir(path.join(directory, item)));
                    Promise.all(dirs).then(() => {
                        fs.rmdir(directory, resolve)
                    })
                })
            }
        })
    })
}

// async await

const fsPromises = require('fs/promises')
async function rmdir(directory) {
    const statObj = await fsPromises.stat(directory)
    if (statObj.isFile()) {
        return fsPromises.unlink(directory)
    } else {
        let dirs = await fsPromises.readdir(directory)
        dirs = dirs.map(item => rmdir(path.join(directory, item)));
        await Promise.all(dirs)
        return fsPromises.rmdir(directory)
    }
}

层序遍历

// 采用栈的方式

function rmdirSync(directory) {
    let index = 0;
    let stack = [directory];
    let current;
    while (current = stack[index++]) {
        let statObj = fs.statSync(directory);
        if (statObj.isFile()) {
            fs.unlinkSync(current); // 文件直接删除
        } else {
            stack = [...stack,...fs.readdirSync(current).map(item=> path.join(current,item))]
        }
    }
    let i = stack.length;
    while (i--) {
        fs.rmdirSync(stack[i])
    }
}
rmdirSync("a");