node中实现删除目录的几种方法

作者: White55开解说
来源: 51数据库
2021-08-15

由于删除目录只能删除空目录(如果有子文件或文件夹要先删除)

目录结构算是典型的二叉树模型,所以涉及到遍历树结构

二叉树遍历(分为深度和广度,以及先序,中序,后序之分)

以下以深度先序解决目录删除

在node中由于主线程为单线程, 可以采取串行方式和并行方式

无论用什么方法删除,就一点核心: 如果是文件直接删除, 如果不是就删除所有子文件或子目录, 然后记得(一定记得删除自己)

深度先序(串行)

深度先序(串行回调方式)

const fs = require('fs')
const path = require('path')
function rmdir(filepath, callback) {
  // 先判断当前filepath的类型(文件还是文件夹,如果是文件直接删除, 如果是文件夹, 去取当前文件夹下的内容, 拿到每一个递归)
  fs.stat(filepath, function(err, stat) {
    if(err) return console.log(err)
    if(stat.isfile()) {
      fs.unlink(filepath, callback)
    }else {
      fs.readdir(filepath, function(err, data) {
        if(err) return console.log(err)
        let dirs = data.map(dir => path.join(filepath, dir))
        let index = 0
        !(function next() {
          // 此处递归删除掉所有子文件 后删除当前 文件夹
          if(index === dirs.length) {
            fs.rmdir(filepath, callback)
          }else {
            rmdir(dirs[index++],next)
          }
        })()
      })
    }
  })
}

rmdir('a', function() {
  console.log('删除成功')
})

深度先序 (串行 promise写法)

const fs = require('fs')
const path = require('path')
function rmdirpromise(filepath) {
  return new promise((resolve, reject) => {
    fs.stat(filepath, function(err, stat) {
      if(err) reject(err)
      if(stat.isfile()) {
        fs.unlink(filepath, function(err) {
          if(err) reject(err)
          resolve()
        })
      }else {
        fs.readdir(filepath, function(err, dirs) {
          if(err) reject(err)
          dirs = dirs.map(dir => path.join(filepath, dir)) // a/b a/c
          let index = 0;
          (function next() {
            if(index === dirs.length) {
              fs.rmdir(filepath, function(err) {
                if(err) reject(err)
                resolve()
              })
            }else {
              rmdirpromise(dirs[index++]).then(() => {
                next()
              }, err => {
                reject(err)
              })
            }
          })()
        })
      }
    })
  })
}

rmdirpromise('a').then(() => {
  console.log('删除成功')
})

深度先序 (串行 async await写法)

// 在node v10.0.0+版本中fs模块提供 promise 写法 const fs = require('fs').promises
// 如果在node 10之前的版本中可以引入第三方模块 mz const fs = require('mz/fs') 用法一致 http://www.51sjk.com/Upload/Articles/1/0/268/268543_20210708023931191.jpg
const fs = require('fs').promises
const path = require('path')
async function rmdirasync(filepath) {
  let stat = await fs.stat(filepath)
  if (stat.isfile()) {
    await fs.unlink(filepath)
  } else {
    let dirs = await fs.readdir(filepath)
    dirs = dirs.map(dir => path.join(filepath, dir))
    let index = 0;
    (async function next() {
      if (index === dirs.length) {
        await fs.rmdir(filepath)
      } else {
        await rmdirasync(dirs[index++])
        await next()
      }
    })()
  }
}

rmdirasync('a').then(() => {
  console.log('删除成功')
}, (err) => {
  console.log('err', err)
})

深度先序 (并行)

深度先序 (并行回调写法)

const fs = require('fs').promises
const path = require('path')

function rmdir(filepath, callback) {
  fs.stat(filepath, function(err,stat) {
    if(err) return console.log(err)
    if(stat.isfile()) {
      fs.unlink(filepath, callback)
    }else {
      fs.readdir(filepath, function(err, dirs) {
        if(err) return console.log(err)
        // 此处要添加dirs.length的验证,不然如果length为0 后面的foreach不执行, 就删不掉当前目录了, 也执行不了callback
        if(dirs.length === 0) {
          fs.rmdir(filepath, callback)
        }
        dirs = dirs.map(dir => path.join(filepath, dir))
        // 通过计数的方式来判断是否子目录都删除了
        let index = 0
        function done() {
          if(++index === dirs.length) {
            fs.rmdir(filepath, callback)
          }
        }
        // 何为并行? a下有两个目录b, c,那么同时将b, c的删除都推到event loop中,用for循环实现
        dirs.foreach(dir => {
          // 通过done回调的方式来控制js执行流程(lazyman问题也是这么解决的)
          rmdir(dir, done)
        });
      })
    }
  })
}
rmdir('a', function() {
  console.log('删除成功')
})

深度先行 (并行promise写法)

const fs = reqire('fs')
const path = require('path')
function rmdirpromise(filepath) {
  return new promise((resolve, reject) => {
    fs.stat(filepath, function (err, stat) {
      if (err) reject(err)
      if (stat.isfile()) {
        fs.unlink(filepath, function (err) {
          if (err) reject(err)
          resolve()
        })
      } else {
        fs.readdir(filepath, function (err, dirs) {
          if (err) reject(err)
          dirs = dirs.map(dir => path.join(filepath, dir))
          dirs = dirs.map(dir => rmdirpromise(dir))
          promise.all(dirs).then(() => {
            fs.rmdir(filepath, resolve)
          })
        })
      }
    })
  })
}

rmdirpromise('a').then(() => {
  console.log('删除成功')
})

深度先序 (并行 async + await写法)

const fs = require('fs').promises
const path = require('path')
async function rmdirasync(filepath) {
  let stat = await fs.stat(filepath)
  if(stat.isfile()) {
    await fs.unlink(filepath)
  }else {
    let dirs = await fs.readdir(filepath)
    dirs = dirs.map(dir => rmdirasync(path.join(filepath, dir)))
    await promise.all(dirs)
    await fs.rmdir(filepath)
  }
}

rmdirasync('a').then(() => {
  console.log('删除成功')
})

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。