创建文件夹

假如我们要创建这样一个文件夹‘a/d/c/d/e’

同步创建文件夹

let fs = require('fs');
function makep(dir) {
  let paths = dir.split('/');
  for(let i =1;i<paths.length;i++){
    let 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;i<files.length;i++){
    let 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('删除成功')
});

结语

上面的函数中大量使用到递归，如果对递归不太了解的话，理解起来会吃力一些。