node中实现文件夹删除操作

/**
 * 异步的方法
 * fs.mkdirSync fs.mkdir 目录创建是要一层一层的创建
 * fs.stat 可以用于描述文件的状态，如果不存文件，就发生错误
 * fs.existsSync只有同步方法 异步已经被废弃了
 */
// const fs = require('fs');
// function mkdir(pathStr,cb){
//   let pathList = pathStr.split('/'); //[a,b,c,d]
//   // 通过计数方法统计创建文件夹成功
//   let index = 1;
//   function make(err){
//     // 递归创建文件夹错误处理
//     if(err) return cb(err)
//     // 最后一次的下一次 不在进行递归调用
//     if(index == pathList.length + 1) return cb()
//     let currentPath = pathList.slice(0,index++).join('/') // a a/b
//     fs.stat(currentPath,function(err){
//       // 没有路径就报错
//       if(err){
//         fs.mkdir(currentPath,make)
//       }else{
//         // 如果已经有了文件夹直接递归
//         make()
//       }
//     })
//   }
//   make()
// }

/**
 * 改写成async await 使用for循环创建就可以了
 * 采用回调的方式是只能通过回调函数知道是否创建完成
 */
// node11以后可以使用异步模块
//  const fs = require('fs').promises;
//  console.log(fs)
// const {existsSync} = require('fs')
// async function mkdir(pathStr){
//   let pathList = pathStr.split('/'); //[a,b,c,d]
//   console.log(pathList)
//   for(let i = 1;i <= pathList.length;i++){
//     let currentPath = pathList.slice(0,i).join('/') // a a/b
//     console.log(currentPath)
//     if(!existsSync(currentPath)){
//       await fs.mkdir(currentPath)
//     }
//   }
// }
// mkdir('a/b/c/d')
// mkdir('a/b/c/d',function(err){
//   if(err) return console.log(err)
//   console.log('创建成功')
// })

 
// 删除目录 
/**
 * 删除文件 如果内部有文件就不能直接删除只能从儿子节点开始删除文件
 * fs.rmdir fs.rmdirSync
 * fs.readdir 查看目录的儿子列表，返回的是一个数组
 * fs.stat 查看文件状态，包括文件的信息，修改的时间，创建的时间，目录的状态（是文件还是文件夹 isFile isDirectory）
 * fs.unlink 删除文件
 */
/**
 * 第一种方法  串行删除文件夹
 * 串行删除的思路就是每次遍历文件夹产生对应的文件夹 用index来记录对应文件夹的个数每次遍历删除，每次遍历讲当前父文件夹的step方法传入到下一层的子文件或者文件夹中，接着删除子文件或者子文件夹,直到没有子文件接着最底层的子文件删除完成 index等于文件的长度接着删除父文件,删除父文件的父文件
 */
 
// 写递归 不要思考多层  先把父子写明白
// function rmdir(dir,cb){
//   if(dir){
//     fs.stat(dir,function(err,statObj){
//       if(statObj.isDirectory()){
//         // 如果是文件夹 要查找当前文件夹内部的所有文件
//         fs.readdir(dir,function(err,dirs){
//           // 拼接目录
//           dirs = dirs.map(item=>path.join(dir,item))
//           console.log(dirs)
//           let index = 0;
//           function step(){
//             console.log('父文件dir:'+dir,'第一个文件'+dirs[index])
//             // 当每次是文件夹的时候将文件夹产生的step函数传递过去最终当当前文件里面的文件或者文件夹删除完成以后删除当前文件夹
//             if(index == dirs.length) fs.rmdir(dir,cb)
//             rmdir(dirs[index++],step)
//           }
//           step()
//         })
//       }else if(statObj.isFile()){
//         console.log(dir)
//         // 如果第一个是文件的话继续调用step方法删除文件夹中其他的文件
//         fs.unlink(dir,cb)
//       }
//     })
//   }
// }

/**
 * 第二种方法并发方法 相同兄弟子树一起同时删除
 * 思路就是如果当前删除的是文件就好说了直接删除调用cb回调，输出删除成功
 * 如果最外层的是文件夹,遍历文件夹内部的文件或者文件夹，并发删除文件或者文件夹将，调用rmdir方法，讲当前的父文件夹的done方法作为cb参数传递进入给下一层文件或者文件夹，如果下一层是文件，那么直接删除调用传过来的done方法,父文件夹的i+1，如果子文件夹还是文件夹继续遍历子文件夹，遍历子文件夹的文件以及文件夹将子文件夹的done传入给下一层文件或者文件夹，直到当最里层的文件或者文件夹删除完成，接着向上开始删除父文件夹
 */
// function rmdir(dir,cb){
//   fs.stat(dir,function(err,statObj){
//     if(statObj.isDirectory()){
//       fs.readdir(dir,function(err,dirs){
//           // 拼接目录
//           dirs = dirs.map(item=>path.join(dir,item))
//           if(!dirs.length){
//             fs.rmdir(dir,cb)
//           }
//           console.log(dirs)
//           // 计数器 表示当i等于文件的长度删除当前文件夹
//           let i = 0;
//           function done(){
//             console.log('当前i和长度',i,dirs.length)
//             if(++i == dirs.length){
//               return fs.rmdir(dir,cb)
//             }
//           }
//           for(let i = 0; i < dirs.length;i++){
//             rmdir(dirs[i],done)
//           } 
//       })
//     }else{
//       // 如果第一个是文件的话继续调用done方法删除文件夹中其他的文件
//       fs.unlink(dir,cb)
//     }
//   })
// }

// 第三种使用同步方法删除文件夹
/**
 * 使用async await方法 将异步方法转换成同步方法
 * async 是generator和co的语法糖 async函数返回的是一个promise
 * 如果是文件的话直接 使用fs.unlink(dir)删除文件
 * 如果是文件夹的话调用Promise.all，这个方法需要让所有的promise都执行完成才结束，所以调用rmdir删除子文件夹，一直递归调用，知道最里层的删除完成返回一个promise接着返回到最外层父文件夹的promise删除完成
 */
// async function rmdir(dir){
//   let statObj = await fs.stat(dir);
//   if(statObj.isDirectory()){
//     let dirs = await fs.readdir(dir)
//     await Promise.all(dirs.map(item=>rmdir(path.join(dir,item))))
//     await fs.rmdir(dir)
//   }else{
//     return fs.unlink(dir)
//   }
// }

/**
 * 第四中方法层序遍历删除文件
 * 将文件层虚遍历放到栈中，接着倒序删除文件
 */
 const fs = require('fs').promises
 const path = require('path')
async function rmdir(dir){
  let stack = [dir]; // 先把根节点进入到队列中
  let index = 0; // 当前索引
  let currentNode; // 不停的移动指针
  while(currentNode = stack[index++]){
    let statObj = await fs.stat(currentNode);
    console.log(statObj)
    if(statObj.isDirectory()){
      let dirs = await fs.readdir(currentNode);
      dirs = dirs.map(item=>path.join(currentNode,item))
      stack = [...stack,...dirs]
    } 
  }
  console.log('所有的文件和文件夹',stack)
}
rmdir('./a',function(data){
  console.log(data)
  console.log('删除成功')
})
// rmdir('./a').then(data=>{
//   console.log(data,'删除成功')
// })