使用node中fs模塊建立和刪除文件夾

建立文件夾

假如咱們要建立這樣一個文件夾‘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('刪除成功')
});

複製代碼

結語

上面的函數中大量使用到遞歸，若是對遞歸不太瞭解的話，理解起來會吃力一些。