fs模块(二)

前言

这一节主要用递归或者while来创建、删除目录。

创建目录

fs.mkdir不能自动创建空目录，也就是说如果没有b目录，fs.mkdir('./a/b/c/d')就会报错。

改善这一缺陷的同步创建目录

function mkdirSync (directory) {
  let isAbsolute = path.isAbsolute(directory)
  // ['', 'User', ....]
  // 排除绝对路径split后第一个参数为空的情况
  let dirs = directory.split('/').filter(dir => dir)
  dirs.forEach((dir, idx) => {
    // 数组方法为前闭后开
    let current = dirs.slice(0, idx + 1).join('/')
    if (isAbsolute) {
      current = insertStr(current, 0, '/')
    }
    try {
      fs.accessSync(current)
    } catch (e) {
      fs.mkdirSync(current)
    }
  })
}

mkdirSync(path.resolve(__dirname, './test/a/b/c/d'))
mkdirSync('./test/a2/b2/c2/d2')

异步创建目录

function mkdirAsync (directory, cb) {
  console.log(directory)
  let isAbsolute = path.isAbsolute(directory)
  // ['', 'User', ....]
  // 排除绝对路径split后第一个参数为空的情况
  let dirs = directory.split('/').filter(dir => dir)
  const dirsLen = dirs.length
  function next (idx) {
    if (idx === dirsLen) return cb()
    let current = dirs.slice(0, idx + 1).join('/')
    if (isAbsolute) {
      current = insertStr(current, 0, '/')
    }
    fs.access(current, (err) => {
      if (err) {
        fs.mkdir(current, (err) => {
          if (err) return console.log(err)
          idx += 1
          next(idx)
        })
      } else {
        idx += 1
        next(idx)
      }
    })
  }
  next(0)
}

mkdirAsync(path.resolve(__dirname, './test/e/f/g/h'), () => {
  console.log('创建成功')
})
mkdirAsync('./test/d2/e2/f2/g2', () => {
  console.log('创建成功')
})

异步创建目录async版本

async function mkdirAsync2 (directory) {
  const sep = path.sep
  const dirs = directory.split(sep)
  const len = dirs.length
  let idx = 1
  function mk () {
    if (idx > len) return // 因为slice前闭后开，所以要到len才能包含最后一位
    const current = dirs.slice(0, idx).join(sep)
    try {
      fs.accessSync(current)
      idx++
      mk()
    } catch (e) {
      fs.mkdirSync(current)
      mk()
    }
  }
  await mk()
}

mkdirAsync2('./test/32gggggg/d/f/g/h').then(() => {
  console.log('./test/g/d/f/g/h创建成功')
})

async function observeIsExist (dir) {
  return new Promise((resolve, reject) => {
    fs.access(dir, (err) => {
      if (err) reject(err)
      resolve()
    })
  })
}

async function mkDir (dir) {
  return new Promise((resolve, reject) => {
    fs.mkdir(dir, (err) => {
      if (err) reject(err)
      resolve()
    })
  })
}

async function mkDirByPromise (directory) {
  const sep = path.sep
  const dirs = directory.split(sep)
  const len = dirs.length
  for (let i = 1; i < len + 1; ++i) {
    const current = dirs.slice(0, i).join(sep)
    try {
      await observeIsExist(current)
    } catch (e) {
      await mkDir(current)
    }
  }
}

mkDirByPromise('./test/4d/d/f/g/h').then(() => {
  console.log('./test/g/d/f/g/h创建成功')
})

删除目录

fs.rmdir也是如此，只能删除一个目录，不能递归删除。

先序 深度 同步版本，效率较低

function removeDeepSync (directory) {
  const statObj = fs.statSync(directory)
  if (statObj.isDirectory()) {
    const childDirs = fs.readdirSync(directory)
    // 先删子目录
    childDirs.forEach((dir) => {
      removeDeepSync(path.resolve(directory, './', dir))
    })
    // 再删父目录
    fs.rmdirSync(directory)
  } else {
    fs.unlinkSync(directory)
  }
}
removeDeepSync('./test/a2')

先序 广度 同步版本，效率最低

// 先序 广度 同步
// 广度的基本思路：遍历每层目录，列出所有文件及文件夹，然后从最底层开始删除，一直删到最上面一层
// 比如 这样到目录结构['a', 'a/b', 'a/c', 'a/b/d', 'a/c/e'] -> 倒序删除
function removeWideSync (directory) {
  let dirs = [directory]
  let idx = 0
  // 这里用while循环
  while (dirs[idx]) {
    const statObj = fs.statSync(dirs[idx])
    if (statObj.isDirectory()) {
      let childDirs = fs.readdirSync(dirs[idx])
      // 注意这里只要和父级resolve就可以，不用每次都从0-idx，这样会造成路径多次叠加
      childDirs = childDirs.map((dir) => path.resolve(dirs[idx], './', dir))
      dirs = [...dirs, ...childDirs]
    }
    idx++
  }
  // 还可以用递归
  // function push (idx) {
  //   if (idx === dirs.length) return
  //   const statObj = fs.statSync(dirs[idx])
  //   if (statObj.isDirectory()) {
  //     let childDirs = fs.readdirSync(dirs[idx])
  //     // 注意这里只要和父级resolve就可以，不用每次都从0-idx，这样会造成路径多次叠加
  //     childDirs = childDirs.map((dir) => path.resolve(dirs[idx], './', dir))
  //     dirs = [...dirs, ...childDirs]
  //   }
  //   idx += 1
  //   push(idx)
  // }
  // push(0)
  dirs.reverse().forEach((dir) => {
    const statObj = fs.statSync(dir)
    if (statObj.isDirectory()) {
      fs.rmdirSync(dir)
    } else {
      fs.unlink(dir)
    }
  })
}

removeWideSync('./test/e')

先序 异步 串行 广度，效率最低

// 先序 异步 串行 广度
// ['a', 'a/b', 'a/c', 'a/b/d', 'a/b/e, 'a/c/d', 'a/c/e']
function removeWideParallelAsync (directory, cb) {
  let dirs = [directory]
  function flatTree (idx) {
    if (idx === dirs.length) return rm()
    let current = dirs[idx]
    fs.stat(current, (err, stat) => {
      if (err) return console.log(err)
      if (stat.isDirectory()) {
        fs.readdir(current, (err, childDirs) => {
          if (err) return console.log(err)
          childDirs = childDirs.map((dir) => path.resolve(current, dir))
          dirs = dirs.concat(childDirs)
          flatTree(++idx)
        })
      } else {
        flatTree(++idx)
      }
    })
  }
  flatTree(0)

  function rm () {
    const current = dirs.pop()
    if (!current) return cb()

    fs.stat(current, (err, stat) => {
      if (err) return console.log(err)
      if (stat.isDirectory()) {
        fs.rmdir(current, rm)
      } else {
        fs.unlink(current, rm)
      }
    })
  }
}

removeWideParallelAsync('./test/a2', () => {
  console.log('删除成功')
})

先序 异步 深度 串行版本，效率较低

// 先序 异步 深度 串行

function removeDeepSerialAsync (directory, cb) {
  fs.stat(directory, (err, stat) => {
    if (err) return console.log(err)
    if (stat.isDirectory()) {
      fs.readdir(directory, (err, files) => {
        if (err) return console.log(err)
        let idx = 0
        const len = files.length
        if (files.length > 0) {
          let current = path.resolve(directory, files[idx])
          removeDeepSerialAsync(current, final)
        } else {
          fs.rmdir(directory, (err) => {
            if (err) return console.log(err)
            cb()
          })
        }
        // 会发现，这个final做的事情，其实和上面的是一样的。
        // 遇到这种情况，说明这个递归还可以优化。
        // 将两部分互补一下，生成一个函数调用就可以了。
        function final () {
          if (++idx < len) {
            let current = path.resolve(directory, files[idx])
            removeDeepSerialAsync(current, cb)
          } else {
            console.log('directory', directory)
            fs.rmdir(directory, (err) => {
              if (err) return console.log(err)
              cb()
            })
          }
        }
      })
    } else {
      fs.unlink(directory, cb)
    }
  })
}
removeDeepSerialAsync('./test/a2', () => {
  console.log('成功')
})

function removeDeepSerialAsync2 (directory, cb) {
  fs.stat(directory, (err, stat) => {
    if (err) return console.log(err)
    if (stat.isDirectory()) {
      fs.readdir(directory, (err, dirs) => {
        if (err) return console.log(err)
        // 这里直接可以直接resolve directory的原因是
        // 这里的dirs是它的直接子目录
        dirs = dirs.map((dir) => path.resolve(directory, dir))
        function next (idx) {
          // 所有最底层的空目录在这里被删除
          if (idx === dirs.length) {
            fs.rmdir(directory, (err) => {
              if (err) return console.log(err)
              cb()
            })
          } else {
            // 相当于有两层递归
            // 这里的next用于删除相邻目录
            removeDeepSerialAsync2(dirs[idx], () => next(idx + 1))
          }
        }
        next(0)
      })
    } else {
      // 所有最底层的文件在这里被删除
      fs.unlink(directory, cb)
    }
  })
}

removeDeepSerialAsync2('./test/a', () => {
  console.log('成功')
})

function removeDeepSerialAsync3 (directory, cb) {
  fs.stat(directory, (err, stat) => {
    if (err) return console.log(err)
    // 如果是文件，那么继续往下深探，从最底层的开始删除，删完了删同层级的，同层级的删完了删父级本身。
    if (stat.isDirectory()) {
      fs.readdir(directory, (err, childDirs) => {
        if (err) return console.log(err)
        childDirs = childDirs.map((dir) => path.resolve(directory, dir))
        function next (idx) {
          if (idx === childDirs.length) {
            return fs.rmdir(directory, cb)
          }
          removeDeepSerialAsync3(childDirs[idx], () => { next(++idx) })
        }
        next(0)
      })
    } else {
      fs.unlink(directory, cb)
    }
  })
}
// 如果是以下目录结构
//       a
//   b       c
// d   e   f   h.txt

// 删除顺序就是d、e、b、f、h.txt、c、a
removeDeepSerialAsync3('./test/a', () => {
  console.log('成功')
})

先序 深度 并行 异步版本，效率最高。异步的核心其实都是找到最里层的空目录和文件进行删除。

// 先序 深度 并行 异步
// 异步的核心其实都是找到最里层的**空目录**和**文件**进行删除
// 并行删除的核心就需要计数，等所有直接子目录或子文件都删除完了，就删除父级目录。
function removeDeepParallelAsync2 (directory, cb) {
  fs.stat(directory, (err, stat) => {
    if (err) return console.log(err)
    if (stat.isDirectory()) {
      fs.readdir(directory, (err, childDirs) => {
        if (err) return console.log(err)
        const len = childDirs.length
        if (len === 0) {
          fs.rmdir(directory, (err) => {
            if (err) return console.log(err)
            cb()
          })
        }
        let idx = 0
        childDirs.forEach((dir) => {
          dir = path.resolve(directory, dir)
          removeDeepParallelAsync2(dir, done)
        })
        function done () {
          if (++idx === len) {
            fs.rmdir(directory, (err) => {
              if (err) return console.log(err)
              cb()
            })
          }
        }
      })
    } else {
      fs.unlink(directory, (err) => {
        if (err) return console.log(err)
        cb()
      })
    }
  })
}

removeDeepParallelAsync2('./test/a2', () => {
  console.log('成功')
})

先序 异步 深度 并行

// 先序 异步 深度 并行
function removeDeepParallelAsyncPromise (directory) {
  return new Promise((resolve, reject) => {
    fs.stat(directory, (err, stat) => {
      if (err) return console.log(err)
      if (stat.isDirectory()) {
        fs.readdir(directory, (err, childDirs) => {
          if (err) return console.log(err)
          childDirs = childDirs.map((dir) => removeDeepParallelAsyncPromise(path.resolve(directory, dir)))
          Promise.all(childDirs).then(() => fs.rmdir(directory, resolve))
        })
      } else {
        fs.unlink(directory, resolve)
      }
    })
  })
}

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