创建文件夹
假如我们要创建这样一个文件夹‘a/d/c/d/e’
同步创建文件夹
let fs = require('fs');
function makep(dir) {
let paths = dir.split('/');
for(let i =1;ilet newPath = paths.slice(0,i).join('/');
try{
//是否能访问到这个文件，如果能访问到，说明这个文件已经存在，进入循环的下一步。
//accessSync的第二个参数就是用来判断该文件是否能被读取
fs.accessSync(newPath,fs.constants.R_OK);
}catch (e){
fs.mkdirSync(newPath);
}
}
}
makep('a/d/c/d/e')
复制代码 同步创建会有性能的问题，所以这种创建方式是不推荐的，我们最好用异步创建
异步创建文件夹
我们使用递归来创建文件夹
function mkdirSync(dir,cb) {
let paths = dir.split('/');
let index =1;
function next(index) {
//递归结束判断
if(index>paths.length)return cb();
let newPath = paths.slice(0,index).join('/');
fs.access(newPath,function (err) {
if(err){//如果文件不存在，就创建这个文件
fs.mkdir(newPath,function (err) {
next(index+1);
});
}else{
//如果这个文件已经存在，就进入下一个循环
next(index+1);
}
})
}
next(index);
}
mkdirSync('a/b/c/d/e',function () {
console.log('创建成功')
})
复制代码删除文件夹
首先，我们必须先判断该文件是否为非空文件；如果是空文件就删除，如果不是空，那么先删除子文件，直到父级文件为空，再删父级文件。
同步删除文件夹
function removeDir(dir) {
let files = fs.readdirSync(dir)
for(var i=0;ilet newPath = path.join(dir,files[i]);
let stat = fs.statSync(newPath)
if(stat.isDirectory()){
//如果是文件夹就递归下去
removeDir(newPath);
}else {
//删除文件
fs.unlinkSync(newPath);
}
}
fs.rmdirSync(dir)//如果文件夹是空的，就将自己删除掉
}
removeDir('a');
复制代码 异步删除文件夹
promise版
function removePromise(dir) {
return new Promise(function (resolve, reject) {
//先读文件夹
fs.stat(dir,function (err, stat) {
if(stat.isDirectory()){
fs.readdir(dir,function (err, files) {
files = files.map(file=>path.join(dir,file)); // a/b a/m
files = files.map(file=>removePromise(file)); //这时候变成了promise
Promise.all(files).then(function () {
fs.rmdir(dir,resolve);
})
})
}else {
fs.unlink(dir,resolve)
}
})
})
}
removePromise('a').then(function () {
console.log('删除成功')
})
复制代码异步删除-深度优先遍历
深度优先的主要思想就是“不撞南墙不回头”，“一条路走到黑”，如果遇到“墙”或者“无路可走”时再去走下一条路。所以文件的删除顺序就是4->5->3->6->2->7->10->11->9->12->8->1
我们用代码来实现
let fs = require('fs');
let path = require('path');
function rmdir(dir,cb) {
fs.readdir(dir,function (err, files) {
next(0);
function next(index) {
if(index == files.length)
return fs.rmdir(dir,cb);
let newPath = path.join(dir,files[index]);
console.log(newPath)
fs.stat(newPath,function (err, stat) {
if(err){
console.log(err);
}
if(stat.isDirectory()){
// 在这里完成深度优先，一层层往下找，直到找到非空文件夹
rmdir(newPath,()=>next(index+1));
}else {
// 删除文件
fs.unlink(newPath,function (err) {
if (err) {
console.error(err);
}
next(index + 1);
});
}
})
}
})
}
rmdir('a',function () {
console.log('删除成功')
});
复制代码异步删除-广度优先
广度优先就是从根节点开始，沿着树的宽度遍历树的节点，如果发现目标，则演算终止
let fs = require('fs');
let path = require('path');
function wide(dir,cb){
let arrs = [dir];
let index = 0;
function rmdir() {
console.log(arrs)
let current = arrs[--index];
if (current) {
fs.stat(current, (err, stat) => {
if (stat.isDirectory()) {
fs.rmdir(current, rmdir);
} else {
fs.unlink(current, rmdir)
}
})
}
}
!function next(){
if(index === arrs.length) {return rmdir();}
let current = arrs[index++];
fs.stat(current,function(err,stat){
if(stat.isDirectory()){
fs.readdir(current,function(err,files){
arrs = [...arrs,...files.map(file=>
path.join(current,file);
})]; // ['a','a/b','a/c','a/b/d','a/c/e'];
next();
});
}else{
next();
}
})
}()
}
wide('a',function () {
console.log('删除成功')
});
复制代码结语
上面的函数中大量使用到递归，如果对递归不太了解的话，理解起来会吃力一些。